Run locally
git clone -- https://github.com/keiichiw/crate-proofs report-12-source-1
git -C report-12-source-1 checkout --detach d0358890f8bdc8e72a376d225667ac162f89e3b8
git -C report-12-source-1 submodule update --init --recursive --checkout
cd report-12-source-1/crc/3.4.0/aeneas/profiles/stage2/proofs
lake build +Stage2Proofs.Partial128 +Stage2Proofs.Partial16 +Stage2Proofs.Partial32 +Stage2Proofs.Partial64 +Stage2Proofs.Partial8 +Stage2Proofs.PartialConstructor128 +Stage2Proofs.PartialConstructor16 +Stage2Proofs.PartialConstructor32 +Stage2Proofs.PartialConstructor64 +Stage2Proofs.PartialConstructor8 +Stage2Proofs.PartialNoTableConstructors +Stage2Proofs.WordProtocolInstances
printf '%s' 'import Aeneas
import Stage2Proofs.Partial128
import Stage2Proofs.Partial16
import Stage2Proofs.Partial32
import Stage2Proofs.Partial64
import Stage2Proofs.Partial8
import Stage2Proofs.PartialConstructor128
import Stage2Proofs.PartialConstructor16
import Stage2Proofs.PartialConstructor32
import Stage2Proofs.PartialConstructor64
import Stage2Proofs.PartialConstructor8
import Stage2Proofs.PartialNoTableConstructors
import Stage2Proofs.WordProtocolInstances
set_option pp.all true
set_option pp.universes true
set_option pp.explicit true
set_option pp.fullNames true
set_option pp.notation false
set_option pp.proofs true
set_option pp.deepTerms true
set_option pp.maxSteps 10000000
-- proofs.rs adapter for Lean 4.35.0 / Aeneas be86ab0f.
-- Uses Lean'\''s environment, Meta telescope and pretty-printer, never source parsing.
open Lean Meta Elab Command
namespace ProofsProbe
meta def moduleOf (env : Environment) (n : Name) : String :=
match env.getModuleIdxFor? n with
| some idx => env.header.moduleNames[idx.toNat]!.toString
| none => ""
meta def pretty (e : Expr) : MetaM String := do
let s := (← ppExpr e).pretty
if s.contains '\''⋯'\'' then
throwError "Lean display contains an omission marker (or literal ⋯); refusing an incomplete proposition"
if s.utf8ByteSize > 1000000 then throwError "Proposition exceeds 1,000,000-byte recording limit"
return s
-- The full statement stays explicit; the inspection view uses Lean notation.
meta def readable (e : Expr) : MetaM String :=
withOptions (fun o =>
let o := o.setBool `pp.all false
let o := o.setBool `pp.explicit false
let o := o.setBool `pp.universes false
o.setBool `pp.notation true) (pretty e)
-- Only a constant'\''s own tag grants a link; names in plain text are never guessed.
partial def segments (code : Widget.CodeWithInfos) (ref : Option Name := none) : Array Json :=
match code with
| .text text => #[Json.mkObj (([("text", toJson text)]) ++
(ref.toList.map fun n => ("ref", toJson n.toString)))]
| .append parts => parts.foldl (fun acc part => acc ++ segments part ref) #[]
| .tag info part =>
let ref := match info.info.val.info with
| .ofTermInfo ti => ti.expr.constName?
| _ => none
segments part ref
meta def readableFields (key : String) (e : Expr) : MetaM (List (String × Json)) := do
let text ← readable e
let base := [(key, toJson text)]
try
let code ← withOptions (fun o =>
let o := o.setBool `pp.all false
let o := o.setBool `pp.explicit false
let o := o.setBool `pp.universes false
let o := o.setBool `pp.notation true
o.setBool `pp.tagAppFns true) (Widget.ppExprTagged e)
let parts := segments code
let joined := String.join (parts.toList.map fun j =>
(j.getObjValAs? String "text").toOption.getD "")
if joined != text || parts.size > 10000 || joined.utf8ByteSize > 1000000 then
return base
return base ++ [(key ++ "_segments", toJson parts)]
catch _ => return base
meta def inspect (n : Name) (ty : Expr) (manual : Bool) : MetaM (Option Json) := do
let env ← getEnv
forallTelescope ty fun xs conclusion => do
let programExpr ← try
let normalized ← Aeneas.Utils.normalizeLetBindings conclusion
let (expr, _) ← Aeneas.Step.getStepSpecFunArgsExpr normalized
pure (some expr)
catch _ => pure none
if programExpr.isNone && !manual then return none
let full ← pretty ty
let program ← match programExpr with
| some expr => pure (toJson (← readable expr))
| none => pure Json.null
let head := toJson (programExpr.bind (·.getAppFn.constName?) |>.map Name.toString)
let mut binders := #[]
for x in xs do
let d ← x.fvarId!.getDecl
let prop ← isProp d.type
binders := binders.push (Json.mkObj ((← readableFields "type" d.type) ++ [
("name", toJson d.userName.toString),
("kind", toJson (if d.binderInfo.isInstImplicit then "instance" else if prop then "hypothesis" else "variable")),
("binder", toJson (if d.binderInfo.isInstImplicit then "instance" else if d.binderInfo.isExplicit then "explicit" else "implicit"))]))
if binders.size > 1000 then throwError "More than 1000 binders"
let some ranges ← findDeclarationRanges? n | throwError "Missing theorem source range: {n}"
let axioms ← Lean.collectAxioms n
let constants := ty.getUsedConstants
let mut definitions := #[]
for nm in constants.extract 0 100 do
let ranges ← findDeclarationRanges? nm
definitions := definitions.push (Json.mkObj [
("name", toJson nm.toString), ("module", toJson (moduleOf env nm)),
("source", match ranges with
| some r => Json.mkObj [("first_line", toJson r.range.pos.line), ("last_line", toJson r.range.endPos.line)]
| none => Json.null)])
return some (Json.mkObj ((← readableFields "conclusion" conclusion) ++ [
("version", toJson (1 : Nat)), ("theorem", toJson n.toString),
("module", toJson (moduleOf env n)), ("statement", toJson full),
("binders", toJson binders),
("program", program), ("program_head", head),
("axioms", toJson (axioms.map Name.toString)),
("first_line", toJson ranges.range.pos.line), ("last_line", toJson ranges.range.endPos.line),
("definitions", toJson definitions), ("definitions_truncated", toJson (decide (constants.size > 100))),
("translation_rerun", toJson false)]))
end ProofsProbe
run_cmd do
let manual : Array Name := #[`CrcPublicWordInstances.digest8_lane0_spec, `CrcPublicWordInstances.digest_with_initial8_lane0_spec, `CrcPublicWordInstances.digest_finalize8_lane0_spec, `CrcPublicWordInstances.digest8_lane1_spec, `CrcPublicWordInstances.digest_with_initial8_lane1_spec, `CrcPublicWordInstances.digest_finalize8_lane1_spec, `CrcPublicWordInstances.digest8_lane16_spec, `CrcPublicWordInstances.digest_with_initial8_lane16_spec, `CrcPublicWordInstances.digest_finalize8_lane16_spec, `CrcPartialNoTableConstructors.checksum8, `CrcPartial8.digest_update_notable, `CrcPartial8.checksum_table1, `CrcPartial8.digest_update_table1, `CrcPartialConstructor8.new_table1, `CrcPartialNoTableConstructors.new_total8, `CrcPublicWordInstances.digest16_lane0_spec, `CrcPublicWordInstances.digest_with_initial16_lane0_spec, `CrcPublicWordInstances.digest_finalize16_lane0_spec, `CrcPublicWordInstances.digest16_lane1_spec, `CrcPublicWordInstances.digest_with_initial16_lane1_spec, `CrcPublicWordInstances.digest_finalize16_lane1_spec, `CrcPublicWordInstances.digest16_lane16_spec, `CrcPublicWordInstances.digest_with_initial16_lane16_spec, `CrcPublicWordInstances.digest_finalize16_lane16_spec, `CrcPartialNoTableConstructors.checksum16, `CrcPartial16.digest_update_notable, `CrcPartial16.checksum_table1, `CrcPartial16.digest_update_table1, `CrcPartialConstructor16.new_table1, `CrcPartialNoTableConstructors.new_total16, `CrcPublicWordInstances.digest32_lane0_spec, `CrcPublicWordInstances.digest_with_initial32_lane0_spec, `CrcPublicWordInstances.digest_finalize32_lane0_spec, `CrcPublicWordInstances.digest32_lane1_spec, `CrcPublicWordInstances.digest_with_initial32_lane1_spec, `CrcPublicWordInstances.digest_finalize32_lane1_spec, `CrcPublicWordInstances.digest32_lane16_spec, `CrcPublicWordInstances.digest_with_initial32_lane16_spec, `CrcPublicWordInstances.digest_finalize32_lane16_spec, `CrcPartialNoTableConstructors.checksum32, `CrcPartial32.digest_update_notable, `CrcPartial32.checksum_table1, `CrcPartial32.digest_update_table1, `CrcPartialConstructor32.new_table1, `CrcPartialNoTableConstructors.new_total32, `CrcPublicWordInstances.digest64_lane0_spec, `CrcPublicWordInstances.digest_with_initial64_lane0_spec, `CrcPublicWordInstances.digest_finalize64_lane0_spec, `CrcPublicWordInstances.digest64_lane1_spec, `CrcPublicWordInstances.digest_with_initial64_lane1_spec, `CrcPublicWordInstances.digest_finalize64_lane1_spec, `CrcPublicWordInstances.digest64_lane16_spec, `CrcPublicWordInstances.digest_with_initial64_lane16_spec, `CrcPublicWordInstances.digest_finalize64_lane16_spec, `CrcPartialNoTableConstructors.checksum64, `CrcPartial64.digest_update_notable, `CrcPartial64.checksum_table1, `CrcPartial64.digest_update_table1, `CrcPartialConstructor64.new_table1, `CrcPublicWordInstances.digest128_lane0_spec, `CrcPublicWordInstances.digest_with_initial128_lane0_spec, `CrcPublicWordInstances.digest_finalize128_lane0_spec, `CrcPublicWordInstances.digest128_lane1_spec, `CrcPublicWordInstances.digest_with_initial128_lane1_spec, `CrcPublicWordInstances.digest_finalize128_lane1_spec, `CrcPublicWordInstances.digest128_lane16_spec, `CrcPublicWordInstances.digest_with_initial128_lane16_spec, `CrcPublicWordInstances.digest_finalize128_lane16_spec, `CrcPartialNoTableConstructors.checksum128, `CrcPartial128.digest_update_notable, `CrcPartial128.checksum_table1, `CrcPartial128.digest_update_table1, `CrcPartialConstructor128.new_table1, `CrcPartialNoTableConstructors.new_total64, `CrcPartialNoTableConstructors.new_total128]
let localModules : Array String := #[]
let roots : Array Name := #[]
let env ← getEnv
let mut closure : Array Name := #[]
let mut pending := roots.toList
while !pending.isEmpty do
let m := pending.head!
pending := pending.tail!
if !closure.contains m then
closure := closure.push m
if let some idx := env.header.moduleNames.findIdx? (· == m) then
pending := (env.header.moduleData[idx]!.imports.toList.map (·.module)) ++ pending
let scope := closure.filter (fun m => localModules.contains m.toString)
for n in manual do
match env.find? n with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: {n}"
for (n, ci) in env.constants.toList do
let explicit := manual.contains n
if explicit || scope.contains (ProofsProbe.moduleOf env n).toName then
if let .thmInfo th := ci then
let result ← liftTermElabM <| ProofsProbe.inspect n th.type explicit
if let some value := result then
liftIO <| IO.println ("proofs.rs:formal:" ++ value.compress)
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.checksum128
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.checksum128"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.checksum128: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.checksum128"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest128_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest128_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest128_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest128_lane0_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial128_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial128_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial128_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial128_lane0_spec"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.new_total128
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.new_total128"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.new_total128: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.new_total128"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest128_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest128_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest128_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest128_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial128_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial128_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial128_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial128_lane16_spec"
run_cmd do
let theorem_name := `CrcPartial128.checksum_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial128.checksum_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial128.checksum_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial128.checksum_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest128_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest128_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest128_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest128_lane1_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial128_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial128_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial128_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial128_lane1_spec"
run_cmd do
let theorem_name := `CrcPartialConstructor128.new_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialConstructor128.new_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialConstructor128.new_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialConstructor128.new_table1"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.checksum16
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.checksum16"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.checksum16: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.checksum16"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest16_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest16_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest16_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest16_lane0_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial16_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial16_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial16_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial16_lane0_spec"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.new_total16
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.new_total16"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.new_total16: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.new_total16"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest16_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest16_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest16_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest16_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial16_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial16_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial16_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial16_lane16_spec"
run_cmd do
let theorem_name := `CrcPartial16.checksum_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial16.checksum_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial16.checksum_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial16.checksum_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest16_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest16_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest16_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest16_lane1_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial16_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial16_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial16_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial16_lane1_spec"
run_cmd do
let theorem_name := `CrcPartialConstructor16.new_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialConstructor16.new_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialConstructor16.new_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialConstructor16.new_table1"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.checksum32
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.checksum32"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.checksum32: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.checksum32"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest32_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest32_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest32_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest32_lane0_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial32_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial32_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial32_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial32_lane0_spec"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.new_total32
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.new_total32"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.new_total32: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.new_total32"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest32_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest32_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest32_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest32_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial32_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial32_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial32_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial32_lane16_spec"
run_cmd do
let theorem_name := `CrcPartial32.checksum_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial32.checksum_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial32.checksum_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial32.checksum_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest32_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest32_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest32_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest32_lane1_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial32_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial32_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial32_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial32_lane1_spec"
run_cmd do
let theorem_name := `CrcPartialConstructor32.new_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialConstructor32.new_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialConstructor32.new_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialConstructor32.new_table1"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.checksum64
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.checksum64"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.checksum64: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.checksum64"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest64_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest64_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest64_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest64_lane0_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial64_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial64_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial64_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial64_lane0_spec"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.new_total64
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.new_total64"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.new_total64: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.new_total64"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest64_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest64_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest64_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest64_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial64_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial64_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial64_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial64_lane16_spec"
run_cmd do
let theorem_name := `CrcPartial64.checksum_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial64.checksum_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial64.checksum_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial64.checksum_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest64_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest64_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest64_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest64_lane1_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial64_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial64_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial64_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial64_lane1_spec"
run_cmd do
let theorem_name := `CrcPartialConstructor64.new_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialConstructor64.new_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialConstructor64.new_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialConstructor64.new_table1"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.checksum8
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.checksum8"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.checksum8: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.checksum8"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest8_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest8_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest8_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest8_lane0_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial8_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial8_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial8_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial8_lane0_spec"
run_cmd do
let theorem_name := `CrcPartialNoTableConstructors.new_total8
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialNoTableConstructors.new_total8"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialNoTableConstructors.new_total8: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialNoTableConstructors.new_total8"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest8_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest8_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest8_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest8_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial8_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial8_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial8_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial8_lane16_spec"
run_cmd do
let theorem_name := `CrcPartial8.checksum_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial8.checksum_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial8.checksum_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial8.checksum_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest8_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest8_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest8_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest8_lane1_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_with_initial8_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_with_initial8_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_with_initial8_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_with_initial8_lane1_spec"
run_cmd do
let theorem_name := `CrcPartialConstructor8.new_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartialConstructor8.new_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartialConstructor8.new_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartialConstructor8.new_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize128_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize128_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize128_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize128_lane0_spec"
run_cmd do
let theorem_name := `CrcPartial128.digest_update_notable
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial128.digest_update_notable"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial128.digest_update_notable: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial128.digest_update_notable"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize128_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize128_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize128_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize128_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize128_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize128_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize128_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize128_lane1_spec"
run_cmd do
let theorem_name := `CrcPartial128.digest_update_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial128.digest_update_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial128.digest_update_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial128.digest_update_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize16_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize16_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize16_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize16_lane0_spec"
run_cmd do
let theorem_name := `CrcPartial16.digest_update_notable
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial16.digest_update_notable"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial16.digest_update_notable: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial16.digest_update_notable"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize16_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize16_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize16_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize16_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize16_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize16_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize16_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize16_lane1_spec"
run_cmd do
let theorem_name := `CrcPartial16.digest_update_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial16.digest_update_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial16.digest_update_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial16.digest_update_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize32_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize32_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize32_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize32_lane0_spec"
run_cmd do
let theorem_name := `CrcPartial32.digest_update_notable
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial32.digest_update_notable"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial32.digest_update_notable: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial32.digest_update_notable"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize32_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize32_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize32_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize32_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize32_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize32_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize32_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize32_lane1_spec"
run_cmd do
let theorem_name := `CrcPartial32.digest_update_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial32.digest_update_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial32.digest_update_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial32.digest_update_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize64_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize64_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize64_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize64_lane0_spec"
run_cmd do
let theorem_name := `CrcPartial64.digest_update_notable
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial64.digest_update_notable"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial64.digest_update_notable: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial64.digest_update_notable"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize64_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize64_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize64_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize64_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize64_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize64_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize64_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize64_lane1_spec"
run_cmd do
let theorem_name := `CrcPartial64.digest_update_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial64.digest_update_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial64.digest_update_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial64.digest_update_table1"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize8_lane0_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize8_lane0_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize8_lane0_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize8_lane0_spec"
run_cmd do
let theorem_name := `CrcPartial8.digest_update_notable
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial8.digest_update_notable"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial8.digest_update_notable: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial8.digest_update_notable"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize8_lane16_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize8_lane16_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize8_lane16_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize8_lane16_spec"
run_cmd do
let theorem_name := `CrcPublicWordInstances.digest_finalize8_lane1_spec
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPublicWordInstances.digest_finalize8_lane1_spec"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPublicWordInstances.digest_finalize8_lane1_spec: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPublicWordInstances.digest_finalize8_lane1_spec"
run_cmd do
let theorem_name := `CrcPartial8.digest_update_table1
match (← getEnv).find? theorem_name with
| some (.thmInfo _) => pure ()
| _ => throwError "Expected a theorem: CrcPartial8.digest_update_table1"
let axioms ← Lean.collectAxioms theorem_name
for ax in axioms do
unless [``propext, ``Classical.choice, ``Quot.sound].contains ax do
throwError "Unapproved axiom in CrcPartial8.digest_update_table1: {ax}"
liftIO <| IO.println "proofs.rs:checked:CrcPartial8.digest_update_table1"
' | lake env lean --stdinSource on GitHub · SARIF with logs (.json)
Recorded run
Completed · 75 checks passed · 0 failed
| Check | Result | Claim |
|---|---|---|
| Lean checked theorem CrcPartialNoTableConstructors.checksum128; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #1 |
| Lean checked theorem CrcPublicWordInstances.digest128_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #2 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial128_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #3 |
| Lean checked theorem CrcPartialNoTableConstructors.new_total128; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #4 |
| Lean checked theorem CrcPublicWordInstances.digest128_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #5 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial128_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #6 |
| Lean checked theorem CrcPartial128.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #7 |
| Lean checked theorem CrcPublicWordInstances.digest128_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #8 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial128_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #9 |
| Lean checked theorem CrcPartialConstructor128.new_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #10 |
| Lean checked theorem CrcPartialNoTableConstructors.checksum16; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #11 |
| Lean checked theorem CrcPublicWordInstances.digest16_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #12 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial16_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #13 |
| Lean checked theorem CrcPartialNoTableConstructors.new_total16; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #14 |
| Lean checked theorem CrcPublicWordInstances.digest16_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #15 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial16_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #16 |
| Lean checked theorem CrcPartial16.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #17 |
| Lean checked theorem CrcPublicWordInstances.digest16_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #18 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial16_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #19 |
| Lean checked theorem CrcPartialConstructor16.new_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #20 |
| Lean checked theorem CrcPartialNoTableConstructors.checksum32; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #21 |
| Lean checked theorem CrcPublicWordInstances.digest32_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #22 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial32_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #23 |
| Lean checked theorem CrcPartialNoTableConstructors.new_total32; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #24 |
| Lean checked theorem CrcPublicWordInstances.digest32_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #25 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial32_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #26 |
| Lean checked theorem CrcPartial32.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #27 |
| Lean checked theorem CrcPublicWordInstances.digest32_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #28 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial32_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #29 |
| Lean checked theorem CrcPartialConstructor32.new_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #30 |
| Lean checked theorem CrcPartialNoTableConstructors.checksum64; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #31 |
| Lean checked theorem CrcPublicWordInstances.digest64_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #32 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial64_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #33 |
| Lean checked theorem CrcPartialNoTableConstructors.new_total64; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #34 |
| Lean checked theorem CrcPublicWordInstances.digest64_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #35 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial64_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #36 |
| Lean checked theorem CrcPartial64.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #37 |
| Lean checked theorem CrcPublicWordInstances.digest64_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #38 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial64_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #39 |
| Lean checked theorem CrcPartialConstructor64.new_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #40 |
| Lean checked theorem CrcPartialNoTableConstructors.checksum8; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #41 |
| Lean checked theorem CrcPublicWordInstances.digest8_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #42 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial8_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #43 |
| Lean checked theorem CrcPartialNoTableConstructors.new_total8; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #44 |
| Lean checked theorem CrcPublicWordInstances.digest8_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #45 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial8_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #46 |
| Lean checked theorem CrcPartial8.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #47 |
| Lean checked theorem CrcPublicWordInstances.digest8_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #48 |
| Lean checked theorem CrcPublicWordInstances.digest_with_initial8_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #49 |
| Lean checked theorem CrcPartialConstructor8.new_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #50 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize128_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #51 |
| Lean checked theorem CrcPartial128.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #52 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize128_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #53 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize128_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #54 |
| Lean checked theorem CrcPartial128.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #55 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize16_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #56 |
| Lean checked theorem CrcPartial16.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #57 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize16_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #58 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize16_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #59 |
| Lean checked theorem CrcPartial16.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #60 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize32_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #61 |
| Lean checked theorem CrcPartial32.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #62 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize32_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #63 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize32_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #64 |
| Lean checked theorem CrcPartial32.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #65 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize64_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #66 |
| Lean checked theorem CrcPartial64.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #67 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize64_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #68 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize64_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #69 |
| Lean checked theorem CrcPartial64.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #70 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize8_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #71 |
| Lean checked theorem CrcPartial8.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #72 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize8_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #73 |
| Lean checked theorem CrcPublicWordInstances.digest_finalize8_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #74 |
| Lean checked theorem CrcPartial8.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound | Passed | Claim #75 |
Execution details
- Started
- 2026-10-31T04:53:01.903271+00:00
- Finished
- 2026-10-31T05:11:45.289282+00:00
- Platform
- macos aarch64
- Rust compiler
- rustc 1.91.1 (ed61e7d7e 2025-11-07) binary: rustc commit-hash: ed61e7d7e242494fb7057f2657300d9e77bb4fcb commit-date: 2025-11-07 host: aarch64-apple-darwin release: 1.91.1 LLVM version: 21.1.2
- Working directory
- crc/3.4.0/aeneas/profiles/stage2/proofs
- Environment overrides
- None recorded
- Git repository
- https://github.com/keiichiw/crate-proofs
- Git commit
- d0358890f8bdc8e72a376d225667ac162f89e3b8
Diagnostics & logs
=== stdout ===
⚠ [3/5] Ran aeneas:extraDep
warning: building from source; failed to fetch GitHub release (run with '-v' for details)
✔ [5/68] Built AeneasMeta.Simp.RegisterCommand (1.0s)
✔ [6/68] Built AeneasMeta.BvEnumToBitVec (1.3s)
✔ [7/68] Built Aeneas.Data.Coinductive.Effect (934ms)
✔ [8/73] Built Aeneas.Std.Global (1.7s)
✔ [11/74] Built AeneasMeta.UtilsCore (1.9s)
✔ [12/74] Built AeneasMeta.Simp.RegisterCommand:c.o (845ms)
✔ [13/76] Built AeneasMeta.BvEnumToBitVec:c.o (788ms)
✔ [14/76] Built AeneasMeta.UtilsCore:c.o (518ms)
✔ [15/77] Built AeneasMeta.Simp.RegisterCommand:dynlib (645ms)
✔ [16/77] Built Aeneas.Tactic.Solver.Grind.Attribute (1.9s)
✔ [17/77] Built Qq.ForLean.ReduceEval (1.0s)
✔ [18/77] Built Qq.Typ (1.0s)
✔ [19/80] Built AeneasMeta.BvEnumToBitVec:dynlib (503ms)
✔ [20/82] Built AeneasMeta.UtilsCore:dynlib (500ms)
✔ [21/84] Built AeneasMeta.OptionConfig (2.8s)
✔ [22/84] Built Qq.ForLean.ToExpr (1.4s)
✔ [23/84] Built Qq.ForLean.Do (1000ms)
✔ [24/84] Built Qq.SortLocalDecls (875ms)
✔ [29/96] Built Batteries.Util.LibraryNote (1.2s)
✔ [30/96] Built Aeneas.Data.Coinductive.CoInd (4.8s)
✔ [31/99] Built Batteries.CodeAction.Deprecated (1.6s)
✔ [32/99] Built Aeneas.Tactic.Solver.Grind.Init (2.9s)
✔ [33/99] Built AeneasMeta.OptionConfig:c.o (2.7s)
✔ [34/99] Built ImportGraph.Lean.Syntax (891ms)
✔ [35/99] Built Batteries.Tactic.Lint.Basic (1.8s)
✔ [36/102] Built AeneasMeta.OptionConfig:dynlib (439ms)
✔ [37/102] Built ImportGraph.Lean.MessageData (1.3s)
✔ [38/106] Built ImportGraph.Shake.Core (1.1s)
✔ [39/106] Built Aeneas.Data.Coinductive.ITree (1.6s)
✔ [40/107] Built ImportGraph.Lean.EnvExtension (866ms)
✔ [41/113] Built Batteries.Tactic.HelpCmd (2.3s)
✔ [42/116] Built Batteries.Tactic.Lint.Misc (1.7s)
✔ [43/116] Built ImportGraph.Util.Modules (1.0s)
✔ [44/117] Built ImportGraph.Lean.Json (1.5s)
✔ [45/117] Built ImportGraph.Imports.Pretty (2.1s)
✔ [46/118] Built Batteries.Tactic.Alias (2.7s)
✔ [47/118] Built ImportGraph.Shake.EnvExtension (1.1s)
✔ [48/121] Built ImportGraph.Lean.Environment (866ms)
✔ [49/121] Built Qq.Macro (5.4s)
✔ [50/121] Built ImportGraph.Imports.ImportGraph (1.1s)
✔ [51/121] Built ImportGraph.Shake.Basic (1.9s)
✔ [52/121] Built ImportGraph.Graph.TransitiveClosure (989ms)
✔ [53/121] Built ImportGraph.WorkspaceModel.Base (1.1s)
✔ [54/123] Built ImportGraph.Widget.Collapsible (1.3s)
✔ [55/123] Built ImportGraph.Widget.Copy (1.3s)
✔ [56/123] Built ImportGraph.Imports.RequiredModules (1.1s)
✔ [57/123] Built ImportGraph.Widget.GoToModule (1.4s)
✔ [58/124] Built ImportGraph.Tools.ImportDiff (1.4s)
✔ [59/132] Built Qq.Commands (1.4s)
✔ [60/135] Built ImportGraph.Shake.Algebra (1.2s)
✔ [61/135] Built ImportGraph.WorkspaceModel.Model (1.2s)
✔ [62/135] Built ImportGraph.Imports.Redundant (845ms)
✔ [63/135] Built AeneasMeta.Utils (8.1s)
✔ [64/135] Built Qq.Delab (2.2s)
✔ [65/137] Built ImportGraph.WorkspaceModel.Summary.Core (1.5s)
✔ [66/151] Built ImportGraph.Imports.FromSource (1.5s)
✔ [67/153] Built Batteries.Lean.Position (1.0s)
✔ [68/155] Built Batteries.Util.ProofWanted (5.3s)
✔ [69/155] Built ImportGraph.WorkspaceModel.Summary.Cache (1.8s)
✔ [70/163] Built ImportGraph.Tools.MinImports (2.5s)
✔ [71/163] Built ImportGraph.Tools.RedundantImports (2.5s)
✔ [72/164] Built Qq.MetaM (2.1s)
✔ [73/164] Built Mathlib.Tactic.Linter.DirectoryDependency (2.0s)
✔ [74/165] Built Batteries.Tactic.Lint.TypeClass (1.6s)
✔ [75/166] Built ImportGraph.WorkspaceModel.Summary.Get (1.2s)
✔ [76/172] Built Batteries.Tactic.Lint.Simp (2.9s)
✔ [77/177] Built Batteries.Tactic.Unreachable (1.9s)
✔ [78/180] Built ImportGraph.Shake.DeclNeeds (6.2s)
✔ [79/180] Built Qq.Simp (2.2s)
✔ [80/180] Built Qq.MatchImpl (2.1s)
✔ [81/181] Built ImportGraph.WorkspaceModel.Summary (1.6s)
✔ [82/181] Built Batteries.Lean.Meta.Inaccessible (1.8s)
✔ [83/185] Built Qq.AssertInstancesCommute (3.1s)
✔ [84/188] Built Aeneas.Data.Coinductive.ITreeWP.EffectWP (1.2s)
✔ [85/188] Built Batteries.Tactic.Lint.Frontend (4.2s)
✔ [86/188] Built Mathlib.Tactic.Linter.Header (3.5s)
✔ [87/190] Built Batteries.Logic (1.5s)
✔ [88/190] Built ImportGraph.WorkspaceModel.Build (2.3s)
✔ [89/190] Built Aeneas.Tactic.Step.Trace (3.2s)
✔ [90/190] Built Batteries.Lean.NameMapAttribute (1.3s)
✔ [91/190] Built Batteries.Tactic.Lint (1.0s)
✔ [92/190] Built Mathlib.Util.CodeActions.BinderPlicity (2.5s)
✔ [93/190] Built Mathlib.Tactic.TypeStar (2.3s)
✔ [94/190] Built Mathlib.Lean.Elab.Tactic.Meta (2.1s)
✔ [95/190] Built Mathlib.Util.ParseCommand (2.3s)
✔ [96/190] Built ImportGraph.Shake.Environment (5.2s)
✔ [97/190] Built Batteries.Tactic.Trans (4.0s)
✔ [98/190] Built Mathlib.Tactic.MinImports (3.6s)
✔ [99/190] Built Mathlib.Tactic.Linter.TacticDocumentation (2.0s)
✔ [100/190] Built Mathlib.Tactic.Linter.UnusedTacticExtension (2.1s)
✔ [101/190] Built Mathlib.Tactic.Linter.OldObtain (1.0s)
✔ [102/190] Built Mathlib.Tactic.Linter.PrivateModule (2.1s)
✔ [103/190] Built Mathlib.Tactic.Linter.Multigoal (2.2s)
✔ [104/190] Built Mathlib.Tactic.Linter.Whitespace (3.8s)
✔ [105/190] Built Mathlib.Tactic.DeclarationNames (2.1s)
✔ [106/190] Built Mathlib.Tactic.Linter.InternalConstructor (2.1s)
✔ [107/190] Built Qq.Match (8.6s)
✔ [108/190] Built Mathlib.Tactic.Linter.HashCommandLinter (2.1s)
✔ [109/190] Built Mathlib.Tactic.Linter.HaveILetI (2.2s)
✔ [110/190] Built Mathlib.Tactic.Linter.EmptyLine (1.0s)
✔ [111/190] Built Mathlib.Tactic.Linter.DocString (2.1s)
✔ [112/191] Built Mathlib.Lean.Environment (1.2s)
✔ [113/197] Built Mathlib.Tactic.Linter.DeprecatedSyntaxLinter (1.0s)
✔ [114/197] Built Mathlib.Tactic.Linter.DocPrime (2.6s)
✔ [115/197] Built Mathlib.Tactic.Lemma (1.6s)
✔ [116/197] Built Mathlib.Tactic.Linter.AuxLemma (1.6s)
✔ [117/197] Built Mathlib.Tactic.Linter.FlexibleLinter (3.6s)
✔ [118/197] Built Mathlib.Lean.Linter (1.5s)
✔ [119/197] Built Mathlib.Tactic.AdaptationNote (1.8s)
✔ [120/197] Built Mathlib.Lean.Expr.Basic (2.3s)
✔ [121/197] Built Mathlib.Util.CodeActions (1.4s)
✔ [122/199] Built Mathlib.Lean.ContextInfo (1.6s)
✔ [123/220] Built ImportGraph.Tools.NormImports (1.4s)
✔ [124/224] Built Mathlib.Tactic.Linter.Lint (1.5s)
✔ [125/226] Built Qq (1.4s)
✔ [126/226] Built ImportGraph.Shake.Workspace (2.3s)
✔ [127/226] Built Mathlib.Tactic.ExtractGoal (1.8s)
✔ [128/251] Built Mathlib.Tactic.Linter.UnusedTactic (1.9s)
✔ [129/252] Built Mathlib.Lean.Elab.InfoTree (1.6s)
✔ [130/261] Built Batteries.Util.ExtendedBinder (988ms)
✔ [131/261] Built Mathlib.Tactic.TacticAnalysis (1.8s)
✔ [132/261] Built Batteries.Tactic.Init (1.7s)
✔ [133/261] Built Batteries.Lean.Syntax (899ms)
✔ [134/261] Built Mathlib.Tactic.Linter.Style (2.8s)
✔ [135/261] Built Batteries.Lean.Expr (1.3s)
✔ [138/270] Built Batteries.Linter.UnreachableTactic (1.8s)
✔ [139/274] Built Mathlib.Tactic.Linter.UnusedInstancesInType (1.7s)
✔ [140/274] Built ImportGraph.Tools.FindHome (2.6s)
✔ [141/274] Built Aesop.Script.Tactic (1.0s)
✔ [142/274] Built Batteries.Control.Lemmas (881ms)
✔ [143/276] Built AeneasMeta.Utils:c.o (19s)
✔ [144/276] Built Aesop.Nanos (1.2s)
✔ [145/282] Built Aesop.Script.GoalWithMVars (1.4s)
✔ [146/282] Built Aesop.Index.DiscrTreeConfig (994ms)
✔ [147/282] Built AeneasMeta.Utils:dynlib (420ms)
✔ [148/283] Built Batteries.Data.Array.Merge (1.6s)
✔ [149/283] Built Batteries.Tactic.PermuteGoals (1.3s)
✔ [150/285] Built Batteries.Control.AlternativeMonad (1.3s)
✔ [151/285] Built Aesop.Check (912ms)
✔ [152/286] Built Batteries.Lean.MonadBacktrack (1.0s)
✔ [153/286] Built ImportGraph.Tools (1.6s)
✔ [154/287] Built Mathlib.Tactic.TacticAnalysis.Declarations (3.4s)
✔ [155/287] Built Mathlib.Tactic.Linter.OverlappingInstances (2.1s)
✔ [156/296] Built Aesop.Util.UnorderedArraySet (880ms)
✔ [157/297] Built Aesop.Rule.Name (1.0s)
✔ [158/297] Built Aesop.Options.Public (1.0s)
✔ [159/297] Built Batteries.Lean.Meta.Basic (1.2s)
✔ [160/297] Built Aesop.Forward.LevelIndex (693ms)
✔ [161/301] Built AeneasMeta.Extensions (2.2s)
✔ [162/301] Built Aesop.Script.OptimizeSyntax (1.1s)
✔ [163/301] Built Aesop.Forward.PremiseIndex (691ms)
✔ [164/301] Built AeneasMeta.Async.Async (2.5s)
✔ [165/301] Built Mathlib.Tactic.Linter.DeclType (1.5s)
✔ [166/301] Built Aesop.Options.Internal (675ms)
✔ [167/301] Built Aesop.Percent (825ms)
✔ [168/302] Built AeneasMeta.Simp.Simp (2.4s)
✔ [169/303] Built AeneasMeta.Extensions:c.o (858ms)
✔ [170/304] Built Batteries.Lean.Meta.SavedState (1.3s)
✔ [171/304] Built AeneasMeta.Async.Async:c.o (894ms)
✔ [172/304] Built AeneasMeta.Extensions:dynlib (446ms)
✔ [173/304] Built Aesop.Script.TacticState (1.4s)
✔ [174/309] Built AeneasMeta.Async.Async:dynlib (264ms)
✔ [175/309] Built Aesop.Forward.SlotIndex (1.0s)
✔ [176/310] Built Aesop.Util.Basic (2.5s)
✔ [177/310] Built Aesop.Util.UnionFind (994ms)
✔ [178/310] Built AeneasMeta.Simp.Simp:c.o (1.4s)
✔ [179/321] Built Mathlib.Init (1.7s)
✔ [180/321] Built Aesop.Util.EqualUpToIds (2.4s)
✔ [181/321] Built Batteries.Lean.TagAttribute (712ms)
✔ [182/321] Built AeneasMeta.Simp.Simp:dynlib (557ms)
✔ [183/321] Built Batteries.Tactic.SeqFocus (1.5s)
✔ [184/321] Built Aesop.RuleTac.RuleTerm (824ms)
✔ [185/321] Built Aesop.Forward.Substitution (1.4s)
✔ [186/321] Built Aesop.Tracing (1.7s)
✔ [187/321] Built Mathlib.Tactic.SimpRw (1.7s)
✔ [188/321] Built Mathlib.Tactic.Use (1.8s)
✔ [189/321] Built Mathlib.Lean.Elab.Term (1.0s)
✔ [190/321] Built Mathlib.Util.WithWeakNamespace (2.1s)
✔ [191/321] Built Mathlib.Tactic.Inhabit (1.8s)
✔ [192/321] Built Mathlib.Lean.PrettyPrinter.Delaborator (1.6s)
✔ [193/321] Built Mathlib.Tactic.Core (2.6s)
✔ [194/321] Built Mathlib.Tactic.ExtendDoc (2.0s)
✔ [195/321] Built AeneasMeta.Saturate.Attribute (3.0s)
✔ [196/321] Built Mathlib.Basic.Nonempty (1.4s)
✔ [197/321] Built Mathlib.Tactic.Simproc.ExistsAndEq (2.4s)
✔ [198/321] Built Mathlib.Basic.ExistsUnique (1.8s)
✔ [199/321] Built Mathlib.Basic.IsEmpty.Defs (1.8s)
✔ [200/321] Built Mathlib.Tactic.OfNat (1.6s)
✔ [201/321] Built Mathlib.Tactic.Attr.Register (1.9s)
✔ [202/321] Built Mathlib.Data.Nat.Notation (1.5s)
✔ [203/321] Built Mathlib.Data.Int.Notation (1.8s)
✔ [204/321] Built Mathlib.Data.Nat.BinaryRec (1.7s)
✔ [205/321] Built Mathlib.Tactic.CrossRefAttribute (2.5s)
✔ [206/321] Built Mathlib.Tactic.Eqns (1.5s)
✔ [207/321] Built Mathlib.Lean.Meta (1.7s)
✔ [208/321] Built Mathlib.Tactic.Simps.NotationClass (1.9s)
✔ [209/321] Built Mathlib.Tactic.Translate.Attributes (1.6s)
✔ [210/321] Built Mathlib.Data.String.Defs (1.6s)
✔ [211/321] Built Mathlib.Util.AddRelatedDecl (2.7s)
✔ [212/321] Built Mathlib.Lean.Name (1.6s)
✔ [213/321] Built Mathlib.Tactic.Translate.UnfoldBoundary (2.4s)
✔ [214/321] Built Batteries.Lean.AttributeExtra (1.1s)
✔ [215/321] Built Aesop.Script.CtorNames (1.4s)
✔ [216/321] Built Mathlib.Lean.Meta.Simp (1.9s)
✔ [217/321] Built Aesop.Script.Util (1.1s)
✔ [218/323] Built Mathlib.Tactic.Translate.Reorder (3.3s)
✔ [219/323] Built Aesop.RulePattern.Cache (1.2s)
✔ [220/323] Built Mathlib.Tactic.Push.Attr (2.1s)
✔ [221/323] Built Aesop.Index.Basic (1.4s)
✔ [222/323] Built Aesop.Stats.Basic (1.6s)
✔ [223/323] Built AeneasMeta.Saturate.Attribute:c.o (2.9s)
✔ [224/323] Built Mathlib.Tactic.SplitIfs (1.8s)
✔ [225/324] Built Mathlib.Logic.Function.Defs (1.8s)
✔ [226/325] Built AeneasMeta.Simp.SimpAllAssumptions (3.2s)
✔ [227/325] Built AeneasMeta.Saturate.Attribute:dynlib (384ms)
✔ [228/325] Built Mathlib.Tactic.Translate.GuessName (2.3s)
✔ [229/325] Built Mathlib.Tactic.ScopedNS (2.9s)
✔ [230/325] Built Batteries.Linter.UnnecessarySeqFocus (2.1s)
✔ [231/326] Built Aesop.ElabM (1.2s)
✔ [232/326] Built Mathlib.Tactic.MkIffOfInductiveProp (2.6s)
✔ [233/326] Built Aesop.Script.Step (1.8s)
✔ [234/326] Built Aesop.BaseM (1.3s)
✔ [235/326] Built Mathlib.Basic.Logic.Basic (2.6s)
✔ [236/326] Built Mathlib.Basic.Nontrivial.Defs (1.9s)
✔ [237/326] Built Aesop.Util.Tactic.Ext (1.7s)
✔ [238/329] Built Mathlib.Logic.Relator (1.9s)
✔ [239/329] Built AeneasMeta.Simp.SimpAllAssumptions:c.o (2.2s)
✔ [240/329] Built Batteries.Linter (1.1s)
✔ [241/329] Built Aesop.Util.Tactic (800ms)
✔ [242/330] Built Aesop.RuleTac.ElabRuleTerm (1.3s)
✔ [243/330] Built Mathlib.Tactic.SetNotationForOrder (2.6s)
✔ [244/330] Built Aesop.Script.SScript (1.2s)
✔ [245/333] Built AeneasMeta.Simp.SimpAllAssumptions:dynlib (310ms)
✔ [246/333] Built Aesop.Script.UScript (1.2s)
✔ [247/333] Built Aesop.Script.ScriptM (1.3s)
✔ [248/333] Built Mathlib.Tactic.Translate.Expr (3.2s)
✔ [249/333] Built Mathlib.Tactic.Simps.Basic (5.8s)
✔ [250/333] Built Aesop.RuleTac.GoalDiff (1.5s)
✔ [251/333] Built Aesop.Util.Unfold (1.2s)
✔ [252/335] Built Aesop.RulePattern (2.2s)
✔ [253/335] Built Aesop.RuleTac.Forward.Basic (1.3s)
✔ [254/335] Built Batteries.Tactic.Basic (1.7s)
✔ [255/335] Built Batteries.Lean.Meta.UnusedNames (1.2s)
✔ [256/339] Built Aesop.Script.Check (1.4s)
✔ [257/339] Built Aesop.Script.UScriptToSScript (2.3s)
✔ [258/339] Built Aesop.Constants (872ms)
✔ [259/339] Built Aesop.RuleTac.Basic (1.5s)
✔ [260/339] Built Aesop.Util.Tactic.Unfold (1.5s)
✔ [261/340] Built Mathlib.Tactic.Simps (1.9s)
✔ [262/341] Built Batteries.Classes.Order (2.9s)
✔ [263/343] Built AeneasMeta.Simp (4.4s)
✔ [264/344] Built Aesop.EMap (2.9s)
✔ [265/344] Built Aesop.Util.OrderedHashSet (2.5s)
✔ [266/347] Built AeneasMeta.Simp:c.o (622ms)
✔ [267/347] Built AeneasMeta.Simp:dynlib (289ms)
✔ [268/348] Built Aesop.Script.StructureStatic (4.4s)
✔ [269/348] Built Batteries.Lean.Meta.Expr (2.1s)
✔ [270/348] Built Batteries.Lean.PersistentHashMap (1.9s)
✔ [271/352] Built AeneasMeta.Saturate.Tactic (11s)
✔ [272/353] Built Batteries.Data.UInt (3.5s)
✔ [273/356] Built Batteries.Lean.Meta.InstantiateMVars (2.4s)
✔ [274/360] Built Batteries.Lean.PersistentHashSet (1.6s)
✔ [275/361] Built Batteries.Lean.Meta.DiscrTree (1.6s)
✔ [276/363] Built Aesop.Script.StructureDynamic (6.8s)
✔ [277/364] Built Aesop.RuleSet.Name (1.5s)
✔ [278/367] Built Aesop.Script.SpecificTactics (6.8s)
✔ [279/367] Built Batteries.Lean.HashSet (1.4s)
✔ [280/368] Built Aesop.RuleSet.Filter (1.2s)
✔ [281/370] Built Mathlib.Util.Notation3 (13s)
✔ [282/370] Built Aesop.Script.Main (2.0s)
✔ [283/370] Built Aesop.Index.RulePattern (2.2s)
✔ [284/370] Built Aesop.RuleTac.Preprocess (1.4s)
✔ [285/370] Built Aesop.RuleTac.Tactic (1.6s)
✔ [286/401] Built Aesop.Search.Expansion.Basic (1.5s)
✔ [287/401] Built AeneasMeta.Async.TestTactics (5.5s)
✔ [288/402] Built Aesop.RuleTac.Cases (2.2s)
✔ [289/402] Built Aesop.Search.Expansion.Simp (1.7s)
✔ [290/402] Built Aesop.Exception (1.5s)
✔ [291/402] Built Batteries.Control.ForInStep.Basic (1.4s)
✔ [292/405] Built Aesop.RuleTac.Apply (2.2s)
✔ [293/437] Built AeneasMeta.Async.TestTactics:c.o (1.6s)
✔ [294/437] Built Aesop.Stats.Extension (2.0s)
✔ [295/437] Built AeneasMeta.Async.TestTactics:dynlib (400ms)
✔ [296/437] Built Aesop.Frontend.Basic (1.5s)
✔ [297/442] Built Aesop.Stats.File (1.0s)
✔ [298/447] Built Batteries.Data.Array.Basic (6.9s)
✔ [299/447] Built Mathlib.Tactic.Spread (2.4s)
✔ [300/447] Built Aesop.Stats.Report (1.8s)
✔ [301/447] Built Mathlib.Tactic.Translate.Core (16s)
✔ [302/450] Built Mathlib.Tactic.Attr.Core (2.3s)
✔ [303/452] Built Mathlib.Tactic.Lift (2.5s)
✔ [304/452] Built Mathlib.Tactic.Conv (3.1s)
✔ [305/455] Built Aesop.Forward.RuleInfo (2.5s)
✔ [306/455] Built Mathlib.Tactic.Subsingleton (3.1s)
✔ [307/455] Built Mathlib.Tactic.DepRewrite (6.6s)
✔ [308/455] Built Mathlib.Tactic.Translate.TagUnfoldBoundary (3.2s)
✔ [309/455] Built Mathlib.Tactic.Translate.ToAdditive (3.2s)
✔ [310/459] Built Mathlib.Util.AtLocation (2.0s)
✔ [311/459] Built Aesop.Rule.Forward (2.3s)
✔ [312/460] Built Mathlib.Util.CompileInductive (5.0s)
✔ [313/463] Built Mathlib.Tactic.ToAdditive (3.1s)
✔ [314/463] Built Batteries.Data.BinomialHeap.Basic (10s)
✔ [315/463] Built Mathlib.Lean.Meta.CongrTheorems (6.4s)
✔ [316/463] Built Mathlib.Tactic.Relation.Rfl (3.4s)
✔ [317/464] Built Mathlib.Data.Int.Init (5.8s)
✔ [318/469] Built Aesop.Forward.Match.Types (3.1s)
✔ [319/469] Built Mathlib.Tactic.Translate.ToDual (6.3s)
✔ [320/469] Built Mathlib.Control.Combinators (3.6s)
✔ [321/469] Built Mathlib.Data.Option.Defs (3.3s)
✔ [322/469] Built Mathlib.Algebra.Regular.Defs (3.8s)
✔ [323/469] Built Aesop.Index.Forward (2.1s)
✔ [324/469] Built Aesop.RuleTac.Descr (1.9s)
✔ [325/469] Built Mathlib.Algebra.Notation.Defs (5.2s)
✔ [326/469] Built Mathlib.Tactic.Push (8.5s)
✔ [327/469] Built Aesop.Rule.Basic (2.2s)
✔ [328/470] Built Mathlib.Tactic.Coe (3.4s)
✔ [329/472] Built Mathlib.Tactic.ToDual (4.3s)
✔ [330/472] Built Mathlib.Algebra.Notation.Pi.Defs (4.5s)
✔ [331/473] Built Mathlib.Tactic.Contrapose (4.6s)
✔ [332/473] Built Mathlib.Algebra.Group.Semigroup (5.4s)
✔ [333/474] Built Aesop.Rule (2.7s)
✔ [334/474] Built Mathlib.Tactic.CongrExclamation (8.6s)
✔ [335/474] Built Aesop.Index (3.8s)
✔ [336/474] Built Mathlib.Data.Ordering.Basic (2.5s)
✔ [337/474] Built Mathlib.Tactic.TermCongr (9.7s)
✔ [338/474] Built Mathlib.Order.Defs.Prop (2.3s)
✔ [339/474] Built Aesop.RuleSet.Member (1.6s)
✔ [340/474] Built Aesop.Tree.UnsafeQueue (1.7s)
✔ [341/476] Built Mathlib.Data.Set.Defs (4.1s)
✔ [342/477] Built Mathlib.Order.Defs.PartialOrder (3.7s)
✔ [343/479] Built Mathlib.Order.Notation (3.8s)
✔ [344/479] Built Aesop.Forward.Match (3.4s)
✔ [345/479] Built Aesop.Builder.Basic (1.5s)
✔ [346/479] Built Batteries.Data.Except (912ms)
✔ [347/479] Built Mathlib.Tactic.FastInstance (3.2s)
✔ [348/479] Built Mathlib.Algebra.Group.Monoid (5.2s)
✔ [349/479] Built Batteries.Tactic.Exact (1.4s)
✔ [350/479] Built Mathlib.Order.Defs.Unbundled (2.4s)
✔ [351/479] Built Aesop.Tree.Data.ForwardRuleMatches (1.5s)
✔ [352/479] Built AeneasMeta.Saturate.Tactic:c.o (32s)
✔ [353/479] Built Mathlib.Tactic.Convert (3.8s)
✔ [354/479] Built Mathlib.Tactic.GCongr.ForwardAttr (2.3s)
✔ [355/479] Built Mathlib.Order.Defs.LinearOrder (2.8s)
✔ [356/481] Built Aesop.Builder.Unfold (1.2s)
✔ [357/481] Built Aesop.Builder.Apply (1.2s)
✔ [358/481] Built Aesop.Builder.Tactic (1.3s)
✔ [359/481] Built Aesop.Builder.NormSimp (1.3s)
✔ [360/481] Built AeneasMeta.Saturate.Tactic:dynlib (1.0s)
✔ [361/481] Built Aesop.RuleTac.Forward (2.5s)
✔ [362/481] Built Aesop.Builder.Cases (1.4s)
✔ [363/481] Built Aesop.Builder.Constructors (1.4s)
✔ [364/488] Built Batteries.Lean.Except (966ms)
✔ [365/488] Built Aesop.Builder.Forward (2.7s)
✔ [366/488] Built Aesop.Builder.Default (1.5s)
✔ [367/490] Built Aesop.RuleTac (1.9s)
✔ [368/491] Built Batteries.Data.MLList.Basic (2.2s)
✔ [369/491] Built Mathlib.Algebra.Group.DivInvMonoid (3.4s)
✔ [370/492] Built Mathlib.Logic.Function.Basic (4.0s)
✔ [371/492] Built Mathlib.Logic.Relation (4.4s)
✔ [372/494] Built Mathlib.Tactic.PPWithUniv (2.5s)
✔ [373/494] Built Mathlib.Logic.Function.ULift (1.7s)
✔ [374/494] Built Aesop.Forward.State (7.5s)
✔ [375/494] Built Batteries.Control.Nondet.Basic (1.5s)
✔ [376/494] Built Aesop.RuleSet (5.6s)
✔ [377/494] Built Aesop.Frontend.RuleExpr (3.8s)
✔ [378/494] Built Mathlib.Tactic.ByCases (1.0s)
✔ [379/494] Built Mathlib.Algebra.Group.Defs (2.3s)
✔ [380/494] Built Mathlib.Algebra.Notation.Pi.Basic (2.4s)
✔ [381/495] Built AeneasMeta.Saturate (6.5s)
✔ [382/496] Built Mathlib.Data.Sum.Basic (2.3s)
✔ [383/496] Built Mathlib.Data.Sigma.Basic (2.5s)
✔ [384/496] Built Mathlib.Basic.Unique (2.3s)
✔ [385/496] Built AeneasMeta.Saturate:c.o (624ms)
✔ [386/496] Built Mathlib.Logic.Function.Conjugate (1.0s)
✔ [387/496] Built Mathlib.Data.Subtype (2.3s)
✔ [388/496] Built Aesop.Forward.State.Initial (1.6s)
✔ [389/496] Built Aesop.Forward.State.ApplyGoalDiff (1.4s)
✔ [390/496] Built Aesop.Frontend.Extension.Init (1.3s)
✔ [391/496] Built Mathlib.Tactic.Basify.Attr (2.7s)
✔ [392/496] Built AeneasMeta.Saturate:dynlib (500ms)
✔ [393/496] Built Mathlib.Tactic.Basic (2.5s)
✔ [394/496] Built Aesop.Tree.Data (2.6s)
✔ [395/496] Built Mathlib.Tactic.GCongr.Core (7.7s)
✔ [396/496] Built Mathlib.Algebra.Group.Semiconj.Defs (2.1s)
✔ [397/496] Built Mathlib.Data.Bool.Basic (2.2s)
✔ [398/496] Built Mathlib.Logic.Pairwise (2.4s)
✔ [399/496] Built Aesop.Frontend.Extension (1.6s)
✔ [400/496] Built Mathlib.Basic.FunLike.Basic (2.5s)
✔ [401/496] Built Mathlib.Logic.Function.Iterate (2.8s)
✔ [402/496] Built Mathlib.Algebra.Group.InjSurj (4.9s)
✔ [403/496] Built Mathlib.Data.Quot (3.6s)
✔ [404/496] Built Aesop.Tree.Traversal (1.6s)
✔ [405/496] Built Mathlib.Algebra.Group.Pi.Basic (4.1s)
✔ [406/496] Built Aesop.Tree.TreeM (2.2s)
✔ [407/496] Built Aesop.Tree.RunMetaM (1.7s)
✔ [408/496] Built Mathlib.Tactic.Hint (2.7s)
✔ [409/496] Built Aesop.Search.Queue.Class (1.3s)
✔ [410/500] Built Aesop.Frontend.Tactic (1.9s)
✔ [411/500] Built Aesop.Frontend.Attribute (1.9s)
✔ [412/500] Built Aesop.Tree.State (1.6s)
✔ [413/500] Built Mathlib.Algebra.Group.Commute.Defs (2.6s)
✔ [414/500] Built Mathlib.Basic.FunLike.Embedding (2.4s)
✔ [415/500] Built Aesop.Frontend.Command (2.6s)
✔ [416/500] Built Aesop.Saturate (6.0s)
✔ [417/500] Built Aesop.Tree.Stats (1.5s)
✔ [418/500] Built Mathlib.Data.Prod.Basic (3.1s)
✔ [419/500] Built Aesop.Tree.Free (1.5s)
✔ [420/500] Built Aesop.Tree.Tracing (2.1s)
✔ [421/501] Built Aesop.Forward.State.UpdateGoal (1.3s)
✔ [422/501] Built Aesop.Tree.ExtractProof (1.0s)
✔ [423/501] Built Aesop.Tree.ExtractScript (2.2s)
✔ [424/501] Built Mathlib.Tactic.GCongr (2.2s)
✔ [425/501] Built Aesop.Search.SearchM (1.6s)
✔ [426/501] Built Aesop.Search.Queue (1.9s)
✔ [427/501] Built Aesop.BuiltinRules.Subst (1.9s)
✔ [428/501] Built Aesop.BuiltinRules.Rfl (1.5s)
✔ [429/501] Built Aesop.BuiltinRules.Split (1.8s)
✔ [430/501] Built Aesop.Tree.AddRapp (3.3s)
✔ [431/501] Built Aesop.BuiltinRules.Intros (2.0s)
✔ [432/501] Built Aesop.BuiltinRules.Ext (1.0s)
✔ [433/501] Built Aesop.BuiltinRules.DestructProducts (2.1s)
✔ [434/501] Built Aesop.BuiltinRules.ApplyHyps (1.9s)
✔ [435/501] Built Aesop.BuiltinRules.Assumption (1.9s)
✔ [436/501] Built Mathlib.Algebra.Group.Hom.Defs (8.2s)
✔ [437/501] Built Aesop.Tree.Check (2.1s)
✔ [438/505] Built Mathlib.Basic.FunLike.Equiv (2.0s)
✔ [439/506] Built Aesop.Frontend.Saturate (2.0s)
✔ [440/506] Built Aesop.Search.RuleSelection (2.4s)
✔ [441/506] Built Aesop.BuiltinRules (2.3s)
✔ [442/506] Built Mathlib.Data.Int.Order.Basic (3.3s)
✔ [443/506] Built Mathlib.Algebra.Notation.Prod (3.8s)
✔ [444/506] Built Batteries.Data.Nat.Basic (2.0s)
✔ [445/512] Built Mathlib.Algebra.Group.Units.Defs (5.2s)
✔ [446/512] Built Mathlib.Tactic.GRewrite.Core (7.5s)
✔ [447/523] Built Aesop.Frontend (1.8s)
✔ [448/523] Built Batteries.Data.Nat.Lemmas (1.4s)
✔ [450/523] Built Mathlib.Data.Set.CoeSort (2.9s)
✔ [451/523] Built Mathlib.Tactic.ToExpr (3.1s)
✔ [453/524] Built Mathlib.Logic.Equiv.Defs (5.7s)
✔ [454/524] Built Mathlib.Basic.IsEmpty.Basic (3.1s)
✔ [455/525] Built Mathlib.Order.Basic (7.3s)
✔ [456/525] Built Mathlib.Tactic.Finiteness.Attr (2.3s)
✔ [457/525] Built Mathlib.Tactic.GRewrite.Elab (5.2s)
✔ [458/525] Built Mathlib.Tactic.Choose (4.1s)
✔ [459/525] Built Aesop.Search.Expansion.Norm (6.5s)
✔ [460/525] Built Plausible.Random (1.7s)
✔ [461/528] Built Mathlib.Control.EquivFunctor (3.8s)
✔ [462/528] Built Mathlib.Tactic.FBinop (4.8s)
✔ [463/529] Built Mathlib.Data.Nat.Init (5.4s)
✔ [464/529] Built Mathlib.Algebra.Opposites (5.3s)
✔ [465/530] Built Mathlib.Order.OrderDual (4.4s)
✔ [466/532] Built Mathlib.Order.ULift (3.8s)
✔ [467/532] Built Mathlib.Tactic.GRewrite (3.2s)
✔ [468/532] Built Plausible.Shrinkable (1.7s)
✔ [469/532] Built Plausible.Gen (2.6s)
✔ [470/534] Built Mathlib.Algebra.Group.Equiv.Defs (7.5s)
✔ [471/536] Built Mathlib.Logic.Equiv.Prod (6.3s)
✔ [472/536] Built Mathlib.Basic.SProd (2.3s)
✔ [473/536] Built Plausible.Attr (1.0s)
✔ [474/538] Built Aesop.Search.Expansion (4.0s)
✔ [475/538] Built Mathlib.Data.Nat.Basic (2.4s)
✔ [476/538] Built Plausible.Arbitrary (1.4s)
✔ [477/538] Built Mathlib.Order.Compare (2.5s)
✔ [478/539] Built Mathlib.Order.Max (3.4s)
✔ [479/540] Built Plausible.ArbitraryFueled (1.1s)
✔ [480/540] Built Mathlib.Order.RelClasses (3.0s)
✔ [481/541] Built Aesop.Search.ExpandSafePrefix (2.0s)
✔ [482/541] Built Mathlib.Order.Defs.Lattice (3.4s)
✔ [483/546] Built Batteries.Tactic.Case (2.8s)
✔ [484/546] Built Plausible.DeriveShrinkable (3.3s)
✔ [485/546] Built Mathlib.Logic.Equiv.Sum (3.9s)
✔ [486/546] Built Plausible.Sampleable (1.7s)
✔ [489/550] Built Batteries.CodeAction.Attr (1.8s)
✔ [490/550] Built LeanSearchClient.Basic (1.4s)
✔ [491/551] Built Plausible.Functions (2.4s)
✔ [492/551] Built Plausible.DeriveArbitrary (3.7s)
✔ [493/554] Built Batteries.Tactic.GeneralizeProofs (5.6s)
✔ [494/555] Built Mathlib.Order.BoundedOrder.Basic (5.6s)
✔ [495/556] Built Aesop.Search.Main (5.2s)
✔ [496/557] Built Plausible.Testable (4.4s)
✔ [497/557] Built Batteries.CodeAction.Basic (3.1s)
✔ [498/558] Built Mathlib.Tactic.ApplyCongr (2.6s)
✔ [499/558] Built Mathlib.Lean.Meta.Basic (2.5s)
✔ [500/559] Built Batteries.Data.List.Basic (6.0s)
✔ [501/559] Built Batteries.CodeAction.Misc (5.4s)
✔ [502/560] Built LeanSearchClient.Syntax (3.8s)
✔ [503/560] Built Mathlib.Tactic.ApplyWith (2.3s)
✔ [504/560] Built Mathlib.Tactic.ByContra (2.3s)
✔ [505/560] Built Plausible.Tactic (2.0s)
✔ [506/560] Built Mathlib.Tactic.CasesM (2.6s)
✔ [507/562] Built Aesop.Main (2.8s)
✔ [508/562] Built Mathlib.Tactic.ClearExclamation (1.8s)
✔ [509/562] Built Mathlib.Tactic.Check (2.4s)
✔ [510/562] Built Mathlib.Tactic.ApplyAt (2.0s)
✔ [511/563] Built Mathlib.Tactic.ClearExcept (1.9s)
✔ [512/565] Built Plausible (1.4s)
✔ [513/565] Built Batteries.CodeAction.Match (2.2s)
✔ [514/568] Built LeanSearchClient.LoogleSyntax (2.5s)
✔ [515/571] Built Mathlib.Tactic.Clear_ (2.3s)
✔ [516/571] Built Mathlib.Lean.GoalsLocation (1.9s)
✔ [517/577] Built Aesop (1.7s)
✔ [522/577] Built Batteries.CodeAction (1.4s)
✔ [523/577] Built Mathlib.Lean.Meta.KAbstractPositions (2.0s)
✔ [525/581] Built Mathlib.Lean.FoldEnvironment (1.0s)
✔ [529/595] Built LeanSearchClient (1.3s)
✔ [530/600] Built Mathlib.Data.Set.Operations (3.2s)
✔ [531/600] Built Mathlib.Lean.Meta.RefinedDiscrTree.Basic (2.4s)
✔ [532/602] Built ProofWidgets.Compat (1.2s)
✔ [533/602] Built Mathlib.Tactic.NthRewrite (1.0s)
✔ [534/602] Built ProofWidgets.Util (1.5s)
✔ [535/603] Built Mathlib.Data.Option.Basic (2.7s)
✔ [536/603] Built Mathlib.Tactic.CongrM (2.6s)
✔ [537/603] Built Mathlib.Tactic.Constructor (2.4s)
✔ [538/604] Built Mathlib.Control.Basic (2.9s)
✔ [539/605] Built ProofWidgets.Component.Basic (2.1s)
✔ [540/606] Built Mathlib.Lean.Meta.RefinedDiscrTree.Encode (2.9s)
✔ [541/606] Built Mathlib.Lean.MessageData.Trace (2.2s)
✔ [542/606] Built Mathlib.Lean.Meta.RefinedDiscrTree.Initialize (3.7s)
✔ [543/606] Built ProofWidgets.Cancellable (2.1s)
✔ [544/606] Built Mathlib.Order.Monotone.Defs (4.9s)
✔ [545/607] Built ProofWidgets.Component.Panel.Basic (2.4s)
✔ [546/607] Built ProofWidgets.Component.MakeEditLink (2.1s)
✔ [547/608] Built Mathlib.Tactic.DeprecateTo (3.6s)
✔ [548/608] Built Mathlib.Logic.Equiv.Option (4.2s)
✔ [549/608] Built Mathlib.Tactic.DefEqTransformations (4.3s)
✔ [550/608] Built Mathlib.Tactic.DSimpPercent (2.6s)
✔ [551/610] Built Mathlib.Lean.Meta.RefinedDiscrTree.Lookup (3.2s)
✔ [552/610] Built Mathlib.Tactic.ExistsI (1.9s)
✔ [553/611] Built ProofWidgets.Data.Html (5.4s)
✔ [554/611] Built Mathlib.Tactic.ErwQuestion (2.8s)
✔ [555/611] Built Mathlib.Algebra.Group.Basic (10s)
✔ [556/611] Built Mathlib.Tactic.FailIfNoProgress (2.6s)
✔ [557/612] Built Mathlib.Tactic.DefEqAbuse (3.4s)
✔ [558/614] Built Batteries.Util.Cache (1.4s)
✔ [559/614] Built Mathlib.Lean.Meta.RefinedDiscrTree (2.3s)
✔ [560/614] Built Mathlib.Order.Monotone.Basic (4.6s)
✔ [561/614] Built ProofWidgets.Component.FilterDetails (2.1s)
✔ [562/614] Built ProofWidgets.Component.OfRpcMethod (2.4s)
✔ [563/614] Built ProofWidgets.Component.RefreshComponent (3.4s)
✔ [564/614] Built Mathlib.Tactic.FunProp.Decl (4.3s)
✔ [565/617] Built Mathlib.Algebra.Group.SelfInv (3.0s)
✔ [566/622] Built Mathlib.Tactic.FunProp.Mor (2.0s)
✔ [567/623] Built Mathlib.Logic.Equiv.Basic (7.6s)
✔ [568/625] Built Mathlib.Algebra.Group.Semiconj.Basic (4.3s)
✔ [569/625] Built Mathlib.Tactic.Find (3.5s)
✔ [570/625] Built Mathlib.Tactic.FunProp.ToBatteries (3.1s)
✔ [571/625] Built Mathlib.Algebra.Group.Units.Basic (5.8s)
✔ [572/625] Built Mathlib.Tactic.InferParam (1.7s)
✔ [573/627] Built Mathlib.Algebra.Group.Hom.Basic (4.0s)
✔ [574/627] Built Mathlib.Tactic.GuardGoalNums (1.6s)
✔ [575/627] Built Mathlib.Tactic.GrindAttrs (1.9s)
✔ [576/629] Built Mathlib.Tactic.GuardHypNums (1.9s)
✔ [577/630] Built Mathlib.Tactic.HigherOrder (2.1s)
✔ [578/630] Built Mathlib.Algebra.Group.Commute.Basic (2.6s)
✔ [579/633] Built Mathlib.Tactic.ClickSuggestions.Util (4.3s)
✔ [580/633] Built Mathlib.Tactic.FunProp.FunctionData (2.5s)
✔ [581/634] Built Mathlib.Tactic.Linter.HaveLetLinter (1.9s)
✔ [582/634] Built Mathlib.Util.TermReduce (2.3s)
✔ [583/634] Built Mathlib.Order.Lattice (5.4s)
✔ [584/635] Built Mathlib.Tactic.Linter.MinImports (2.0s)
✔ [585/635] Built Mathlib.Tactic.Linter.PPRoundtrip (1.7s)
✔ [586/636] Built AeneasMeta.Async.Test (97s)
✔ [587/636] Built Mathlib.Algebra.Group.Units.Hom (3.7s)
✔ [588/636] Built Mathlib.Algebra.Group.Equiv.Basic (3.8s)
✔ [589/636] Built Mathlib.Tactic.Linter.UpstreamableDecl (1.7s)
✔ [590/636] Built Mathlib.Algebra.Group.Torsion (2.4s)
✔ [591/638] Built Mathlib.Tactic.ClickSuggestions.SectionState (2.2s)
✔ [592/638] Built Mathlib.Tactic.ClickSuggestions.Unfold (2.0s)
✔ [593/638] Built AeneasMeta.Async.Test:c.o (834ms)
✔ [594/639] Built Mathlib.Tactic.FunProp.Types (1.9s)
✔ [595/639] Built Mathlib.Tactic.Observe (2.3s)
✔ [596/639] Built Mathlib.Tactic.RSuffices (1.7s)
✔ [597/639] Built AeneasMeta.Async.Test:dynlib (490ms)
✔ [598/639] Built Mathlib.Tactic.Recover (1.7s)
✔ [599/639] Built Mathlib.Tactic.IrreducibleDef (2.5s)
✔ [600/639] Built Mathlib.Tactic.Rename (1.7s)
✔ [601/640] Built Mathlib.Order.BoundedOrder.Lattice (2.6s)
✔ [602/640] Built Mathlib.Tactic.Linter (1.7s)
✔ [603/640] Built Mathlib.Algebra.Group.Units.Equiv (2.9s)
✔ [604/640] Built Mathlib.Tactic.ClickSuggestions.Apply (2.5s)
✔ [605/640] Built Mathlib.Util.Tactic (1.9s)
✔ [606/642] Built Mathlib.Tactic.ClickSuggestions.ApplyAt (2.4s)
✔ [607/643] Built Mathlib.Algebra.Group.Opposite (3.4s)
✔ [608/644] Built Mathlib.Tactic.Says (2.3s)
✔ [609/645] Built Mathlib.Tactic.ClickSuggestions.Rewrite (3.3s)
✔ [610/645] Built Mathlib.Tactic.FunProp.Theorems (2.0s)
✔ [611/645] Built Mathlib.Algebra.Group.TypeTags.Basic (4.3s)
✔ [612/645] Built Mathlib.Tactic.ClickSuggestions.GRewrite (3.8s)
✔ [613/646] Built Mathlib.Tactic.RenameBVar (1.0s)
✔ [614/647] Built Mathlib.Lean.Elab.Tactic.Basic (1.8s)
✔ [615/647] Built Mathlib.Tactic.Set (2.6s)
✔ [616/647] Built AeneasMeta.Async (3.5s)
✔ [617/648] Built Mathlib.Tactic.FunProp.Attr (1.8s)
✔ [618/648] Built Mathlib.Tactic.SimpIntro (2.1s)
✔ [619/648] Built Mathlib.Tactic.Substs (1.9s)
✔ [620/649] Built AeneasMeta.Async:c.o (328ms)
✔ [621/650] Built Mathlib.Order.Disjoint (4.4s)
✔ [622/650] Built Mathlib.Tactic.SuccessIfFailWithMsg (2.0s)
✔ [623/650] Built AeneasMeta.Async:dynlib (370ms)
✔ [624/651] Built Mathlib.Tactic.SudoSetOption (1.9s)
✔ [625/651] Built Mathlib.Tactic.SwapVar (2.1s)
✔ [626/652] Built Mathlib.Algebra.Group.TypeTags.Hom (3.2s)
✔ [627/652] Built Mathlib.Tactic.ClickSuggestions.FindPremises (3.0s)
✔ [628/653] Built Mathlib.Tactic.Setm (2.9s)
✔ [629/653] Built Mathlib.Tactic.ToFun (2.3s)
✔ [630/653] Built Mathlib.Tactic.ToLevel (1.6s)
✔ [631/656] Built Mathlib.Order.PropInstances (2.5s)
✔ [632/657] Built Mathlib.Tactic.Trace (1.0s)
✔ [633/662] Built Mathlib.Algebra.Group.Prod (6.9s)
✔ [634/662] Built Mathlib.Tactic.FunProp.Core (6.1s)
✔ [635/662] Built Mathlib.Tactic.Tauto (4.1s)
✔ [636/663] Built Mathlib.Tactic.UnsetOption (2.0s)
✔ [637/666] Built Mathlib.Algebra.Group.Equiv.TypeTags (3.1s)
✔ [638/666] Built Mathlib.Tactic.Widget.SelectInsertParamsClass (1.8s)
✔ [639/666] Built Mathlib.Tactic.Variable (3.1s)
✔ [640/666] Built AeneasMeta (4.5s)
✔ [641/666] Built Mathlib.Tactic.ClickSuggestions.TryPremises (3.5s)
✔ [642/666] Built AeneasMeta:c.o (396ms)
✔ [643/671] Built Mathlib.Tactic.FunProp.Elab (2.8s)
✔ [644/671] Built Mathlib.Tactic.WLOG (2.8s)
✔ [645/672] Built AeneasMeta:shared (534ms)
✔ [646/672] Built Mathlib.Util.CountHeartbeats (3.3s)
✔ [647/672] Built Mathlib.Util.PrintSorries (2.8s)
✔ [648/672] Built Mathlib.Data.Set.Basic (4.6s)
✔ [649/672] Built Mathlib.Util.TransImports (2.6s)
✔ [650/681] Built Mathlib.Util.WhatsNew (2.4s)
✔ [651/681] Built Mathlib.Tactic.Widget.SelectPanelUtils (2.2s)
✔ [652/681] Built Mathlib.Tactic.FunProp (1.9s)
✔ [653/681] Built Batteries.Tactic.Congr (2.1s)
✔ [654/681] Built Mathlib.Tactic.ClickSuggestions (2.8s)
✔ [655/683] Built Aeneas.Std.Spec (2.8s)
✔ [656/685] Built Mathlib.Data.Set.Disjoint (2.4s)
✔ [657/691] Built Mathlib.Data.Set.Inclusion (2.6s)
✔ [658/692] Built Mathlib.Tactic.Widget.CongrM (1.8s)
✔ [659/692] Built Mathlib.Order.GaloisConnection.Defs (3.2s)
✔ [660/692] Built Mathlib.Control.ULift (2.0s)
✔ [661/695] Built Mathlib.Tactic.Widget.Calc (3.1s)
✔ [662/695] Built Mathlib.Data.Prod.PProd (1.8s)
✔ [663/695] Built Mathlib.Tactic.Monotonicity.Attr (2.1s)
✔ [664/699] Built Aeneas.Tactic.Step.DspecInduction (5.3s)
✔ [665/699] Built Mathlib.Tactic.Widget.Conv (4.2s)
✔ [666/704] Built Mathlib.Tactic.Widget.LibraryRewrite (4.8s)
✔ [667/704] Built Mathlib.Order.BoundedOrder.Monotone (2.3s)
✔ [668/704] Built Aeneas.Extract.Extract (6.4s)
✔ [669/704] Built Mathlib.Data.Set.Insert (3.9s)
✔ [670/704] Built Mathlib.Util.PPOptions (1.7s)
✔ [671/704] Built Mathlib.Data.ULift (2.5s)
✔ [672/713] Built Mathlib.Order.Interval.Set.Defs (2.2s)
✔ [673/720] Built Mathlib.Algebra.Order.ZeroLEOne (2.4s)
✔ [674/720] Built Mathlib.Order.Bounds.Defs (2.0s)
✔ [675/720] Built Mathlib.Logic.Embedding.Basic (3.5s)
✔ [676/720] Built Aeneas.Extract (2.3s)
✔ [677/721] Built Mathlib.Data.Bool.Set (2.2s)
✔ [678/722] Built Mathlib.Tactic.Common (3.1s)
✔ [679/722] Built Mathlib.Data.Option.NAry (1.8s)
✔ [680/723] Built Mathlib.Data.Set.Subsingleton (3.0s)
✔ [681/723] Built Mathlib.Basic.Nontrivial.Basic (2.3s)
✔ [682/723] Built Mathlib.Order.TypeTags (2.1s)
✔ [683/723] Built Mathlib.Algebra.Order.IsBotOne (2.8s)
✔ [684/725] Built Mathlib.Control.Monad.Basic (1.9s)
✔ [685/727] Built Mathlib.Dynamics.FixedPoints.Defs (1.8s)
✔ [686/730] Built Mathlib.Util.Delaborators (4.5s)
✔ [687/732] Built Mathlib.Order.Heyting.Basic (7.4s)
✔ [688/732] Built Mathlib.Order.SetNotation (4.7s)
✔ [689/732] Built Batteries.Control.ForInStep.Lemmas (877ms)
✔ [690/734] Built Batteries.Data.List.Pairwise (968ms)
✔ [691/736] Built Aeneas.Std.Primitives (4.2s)
✔ [692/739] Built Mathlib.Order.Iterate (2.9s)
✔ [693/745] Built Mathlib.Tactic.SetLike (2.1s)
✔ [694/749] Built Mathlib.Order.RelIso.Basic (5.3s)
✔ [695/756] Built Mathlib.Data.List.TFAE (1.9s)
✔ [696/756] Built Mathlib.Algebra.Group.End (5.5s)
✔ [697/757] Built Mathlib.Order.BooleanAlgebra.Defs (3.2s)
✔ [698/758] Built Mathlib.Data.Part (4.4s)
✔ [699/758] Built Mathlib.Lean.Expr.ExtraRecognizers (2.3s)
✔ [700/761] Built Mathlib.Basic.SetLike.Basic (3.4s)
✔ [701/763] Built Aeneas.Tactic.Step.Simp (2.0s)
✔ [702/764] Built Aeneas.Tactic.Elab.TraitDefault.Init (3.3s)
✔ [703/766] Built Aeneas.Std.Delab (5.1s)
✔ [704/766] Built Mathlib.Data.Set.Notation (2.9s)
✔ [705/775] Built Mathlib.Util.AtomM (2.1s)
✔ [706/777] Built Batteries.Data.List.Lemmas (6.0s)
✔ [707/777] Built Aeneas.Std.Core.Ops (4.5s)
✔ [708/777] Built Mathlib.Algebra.Group.Int.Defs (2.4s)
✔ [709/780] Built Aeneas.Std.Core.Result (4.0s)
✔ [710/780] Built Mathlib.Order.BooleanAlgebra.Basic (5.9s)
✔ [711/783] Built Mathlib.Logic.OpClass (1.0s)
✔ [712/783] Built Mathlib.Util.AtomM.Recurse (2.4s)
✔ [713/783] Built Batteries.Classes.RatCast (920ms)
✔ [714/783] Built Mathlib.Algebra.Order.Monoid.Unbundled.Defs (3.6s)
✔ [715/784] Built Mathlib.Algebra.Group.Equiv.Opposite (4.3s)
✔ [716/786] Built Mathlib.Data.Int.Basic (2.4s)
✔ [717/789] Built Mathlib.Order.Hom.Basic (9.2s)
✔ [718/789] Built Mathlib.Order.WithBot (12s)
✔ [719/789] Built Mathlib.Data.List.Pairwise (3.0s)
✔ [720/789] Built Mathlib.Data.Rat.Init (1.0s)
✔ [721/789] Built Mathlib.Data.Nat.Cast.Defs (2.5s)
✔ [722/793] Built Mathlib.Algebra.Group.IsCommutative (2.4s)
✔ [723/794] Built Mathlib.Order.MinMax (3.7s)
✔ [724/795] Built Mathlib.Order.BooleanAlgebra.Set (5.2s)
✔ [725/795] Built Mathlib.Algebra.GroupWithZero.Defs (3.9s)
✔ [726/795] Built Mathlib.Order.SymmDiff (5.0s)
✔ [727/795] Built Mathlib.Data.Int.Cast.Defs (3.3s)
✔ [728/795] Built Mathlib.Algebra.Group.Even (5.3s)
✔ [729/795] Built Mathlib.Order.Part (5.1s)
✔ [730/799] Built Mathlib.Order.Lex (3.5s)
✔ [731/799] Built Mathlib.Algebra.Notation.Bracket (2.5s)
✔ [732/803] Built Mathlib.Data.Rat.Defs (5.0s)
✔ [733/803] Built Mathlib.Order.Antisymmetrization (5.8s)
✔ [734/807] Built Mathlib.Data.Set.SymmDiff (3.4s)
✔ [735/812] Built Mathlib.Algebra.CharZero.Defs (2.9s)
✔ [736/812] Built Mathlib.Data.Int.Cast.Basic (3.4s)
✔ [737/818] Built Mathlib.Algebra.NeZero (2.7s)
✔ [738/818] Built Mathlib.Algebra.Ring.Defs (5.0s)
✔ [739/818] Built Mathlib.Algebra.Group.Invertible.Defs (2.9s)
✔ [740/818] Built Mathlib.Algebra.Order.Monoid.Unbundled.Basic (8.9s)
✔ [741/818] Built Mathlib.Algebra.GroupWithZero.NeZero (2.9s)
✔ [742/818] Built Mathlib.Algebra.Group.Semiconj.Units (3.5s)
✔ [743/818] Built Mathlib.Algebra.Order.Group.Synonym (6.3s)
✔ [744/818] Built Mathlib.Tactic.TFAE (5.3s)
✔ [745/818] Built Mathlib.Algebra.Group.Hom.Instances (6.3s)
✔ [746/818] Built Mathlib.Order.Interval.Set.Basic (8.7s)
✔ [747/818] Built Mathlib.Tactic.Nontriviality.Core (3.6s)
✔ [748/819] Built Mathlib.Algebra.Ring.Semiconj (2.9s)
✔ [749/819] Built Mathlib.Algebra.Ring.GrindInstances (3.9s)
✔ [750/819] Built Mathlib.Algebra.Ring.Int.Defs (3.9s)
✔ [751/822] Built Mathlib.Algebra.Field.Defs (3.9s)
✔ [752/824] Built Mathlib.Algebra.GroupWithZero.InjSurj (3.7s)
✔ [753/824] Built Mathlib.Algebra.Order.Sub.Defs (4.5s)
✔ [754/824] Built Mathlib.Algebra.GroupWithZero.Basic (5.0s)
✔ [755/824] Built Mathlib.Data.Set.Image (9.3s)
✔ [756/824] Built Mathlib.Algebra.Group.Commute.Units (4.5s)
✔ [757/824] Built Mathlib.Algebra.Order.Ring.Synonym (3.8s)
✔ [758/824] Built Mathlib.Tactic.Nontriviality (2.8s)
✔ [759/824] Built Mathlib.Tactic.Bound.Init (2.4s)
✔ [760/824] Built Mathlib.Algebra.Ring.Basic (3.9s)
✔ [761/826] Built Mathlib.Algebra.Order.GroupWithZero.Defs (3.9s)
✔ [762/826] Built Mathlib.Algebra.Order.Monoid.Unbundled.OrderDual (2.7s)
✔ [763/826] Built Mathlib.Algebra.Group.Invertible.Basic (3.2s)
✔ [764/828] Built Mathlib.Algebra.GroupWithZero.Hom (3.4s)
✔ [765/828] Built Mathlib.Data.Set.Restrict (3.3s)
✔ [766/828] Built Mathlib.Data.Nat.Set (3.1s)
✔ [767/832] Built Mathlib.Order.Directed (4.2s)
✔ [768/835] Built Mathlib.Tactic.Bound.Attribute (4.2s)
✔ [769/838] Built Mathlib.Algebra.Order.Group.Unbundled.Basic (7.3s)
✔ [770/838] Built Mathlib.Algebra.Group.Nat.Defs (3.4s)
✔ [771/838] Built Mathlib.Data.Set.Prod (8.3s)
✔ [772/838] Built Mathlib.Algebra.Ring.InjSurj (10s)
✔ [773/838] Built Mathlib.Algebra.GroupWithZero.Units.Basic (6.7s)
✔ [774/841] Built Mathlib.Data.Nat.Cast.Pi (3.0s)
✔ [775/841] Built Mathlib.Algebra.Divisibility.Basic (6.8s)
✔ [776/841] Built Mathlib.Algebra.Order.Monoid.Unbundled.Pow (7.0s)
✔ [777/841] Built Mathlib.Data.Nat.Cast.NeZero (3.5s)
✔ [778/841] Built Mathlib.Algebra.GroupWithZero.Nat (2.8s)
✔ [779/841] Built Mathlib.Algebra.Ring.Hom.Defs (8.0s)
✔ [780/841] Built Mathlib.Algebra.Order.Group.OrderIso (4.6s)
✔ [781/841] Built Mathlib.Algebra.Group.Nat.Hom (3.3s)
✔ [782/845] Built Mathlib.Algebra.GroupWithZero.Invertible (3.3s)
✔ [783/845] Built Mathlib.Algebra.Ring.Rat (4.3s)
✔ [784/848] Built Mathlib.Algebra.GroupWithZero.Semiconj (3.0s)
✔ [785/851] Built Mathlib.Data.Set.NAry (3.8s)
✔ [786/854] Built Mathlib.Algebra.Ring.Nat (2.8s)
✔ [787/858] Built Mathlib.Order.Bounds.Basic (10s)
✔ [788/858] Built Mathlib.Data.Nat.Sqrt (2.9s)
✔ [789/859] Built Mathlib.Algebra.Divisibility.Hom (4.1s)
✔ [790/859] Built Mathlib.Algebra.Ring.Units (3.8s)
✔ [791/859] Built Mathlib.Algebra.Order.Group.Lattice (4.1s)
✔ [792/859] Built Mathlib.Data.Set.Function (6.7s)
✔ [793/859] Built Mathlib.Algebra.GroupWithZero.Commute (3.2s)
✔ [794/859] Built Mathlib.Data.PNat.Notation (2.2s)
✔ [795/860] Built Mathlib.Algebra.Ring.Invertible (3.0s)
✔ [796/860] Built Mathlib.Data.Nat.Find (2.6s)
✔ [797/860] Built Mathlib.Algebra.Divisibility.Units (3.8s)
✔ [798/860] Built Mathlib.Tactic.HaveI (2.3s)
✔ [799/860] Built Mathlib.Data.Int.Sqrt (3.3s)
✔ [800/860] Built Mathlib.Algebra.Group.Nat.Even (3.5s)
✔ [801/860] Built Mathlib.Order.Bounds.Image (4.7s)
✔ [802/861] Built Mathlib.Order.CompleteLattice.Defs (4.6s)
✔ [803/865] Built Mathlib.Algebra.Ring.Commute (3.7s)
✔ [804/865] Built Mathlib.Data.Nat.Cast.Basic (4.4s)
✔ [805/865] Built Mathlib.Data.Set.Pairwise.Basic (4.0s)
✔ [806/865] Built Mathlib.Algebra.Order.Group.Unbundled.Abs (5.7s)
✔ [807/865] Built Mathlib.Lean.Expr.Rat (2.8s)
✔ [808/868] Built Mathlib.Algebra.GroupWithZero.Units.Lemmas (3.5s)
✔ [809/868] Built Mathlib.Order.WellFounded (4.7s)
✔ [810/868] Built Mathlib.Data.PNat.Defs (3.5s)
✔ [811/868] Built Mathlib.Order.Nat (3.5s)
✔ [812/868] Built Mathlib.Logic.Equiv.Set (6.1s)
✔ [813/870] Built Mathlib.Util.Qq (2.6s)
✔ [814/870] Built Mathlib.Algebra.GroupWithZero.Divisibility (4.9s)
✔ [815/871] Built Mathlib.Algebra.Order.GroupWithZero.Basic (8.8s)
✔ [816/875] Built Mathlib.Algebra.Group.Int.Even (4.7s)
✔ [817/875] Built Mathlib.Data.Nat.Cast.Commute (3.4s)
✔ [818/875] Built Mathlib.Order.ScottContinuity (4.5s)
✔ [819/878] Built Mathlib.Tactic.TryThis (2.2s)
✔ [820/878] Built Mathlib.Data.Ineq (1.8s)
✔ [821/880] Built Mathlib.Data.Nat.Cast.Order.Basic (5.1s)
✔ [822/880] Built Mathlib.Algebra.Order.Group.Unbundled.Int (3.9s)
✔ [823/880] Built Mathlib.Tactic.NormNum.Result (6.1s)
✔ [824/884] Built Mathlib.Algebra.Field.Basic (7.0s)
✔ [825/885] Built Mathlib.Algebra.Order.Monoid.Defs (4.1s)
✔ [826/885] Built Mathlib.Algebra.Order.Monoid.Unbundled.ExistsOfLE (3.8s)
✔ [827/886] Built Mathlib.Algebra.GroupWithZero.Regular (2.7s)
✔ [828/886] Built Mathlib.Algebra.GroupWithZero.Equiv (2.0s)
✔ [829/886] Built Mathlib.Algebra.Group.WithOne.Defs (4.7s)
✔ [830/889] Built Mathlib.Algebra.Ring.Parity (5.9s)
✔ [831/889] Built Mathlib.Order.Hom.Set (7.8s)
✔ [832/889] Built Mathlib.Algebra.Regular.Basic (4.3s)
✔ [833/889] Built Mathlib.Algebra.Order.Group.Defs (4.1s)
✔ [834/889] Built Mathlib.Algebra.Order.Nonneg.Basic (6.1s)
✔ [835/889] Built Mathlib.Tactic.NormNum.Core (5.3s)
✔ [836/892] Built Mathlib.Algebra.Order.Monoid.Canonical.Defs (4.1s)
✔ [837/892] Built Mathlib.Algebra.Order.Group.Int (3.6s)
✔ [838/892] Built Mathlib.Algebra.Order.Ring.Unbundled.Rat (7.0s)
✔ [839/892] Built Mathlib.Algebra.Group.WithOne.Map (4.2s)
✔ [840/892] Built Mathlib.Algebra.Order.Monoid.Units (3.4s)
✔ [841/892] Built Mathlib.Algebra.Order.Monoid.Unbundled.WithTop (8.4s)
✔ [842/892] Built Mathlib.Algebra.Order.Monoid.OrderDual (3.6s)
✔ [843/893] Built Mathlib.Algebra.GroupWithZero.WithZero (7.4s)
✔ [844/897] Built Mathlib.Algebra.Ring.Int.Parity (5.7s)
✔ [845/897] Built Mathlib.Data.Int.Cast.Lemmas (5.7s)
✔ [846/897] Built Mathlib.Order.Preorder.Chain (5.1s)
✔ [847/897] Built Mathlib.Algebra.Order.Group.Nat (3.9s)
✔ [848/903] Built Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags (4.1s)
✔ [849/903] Built Mathlib.Algebra.Order.Group.Units (3.7s)
✔ [850/903] Built Mathlib.Algebra.Order.Monoid.WithTop (3.5s)
✔ [851/903] Built Mathlib.Algebra.Order.Monoid.NatCast (3.7s)
✔ [852/908] Built Mathlib.Data.NNRat.Defs (6.5s)
✔ [853/908] Built Mathlib.Algebra.Order.Monoid.Unbundled.MinMax (4.8s)
✔ [854/908] Built Mathlib.Data.Rat.Lemmas (5.7s)
✔ [855/909] Built Mathlib.Util.SynthesizeUsing (3.1s)
✔ [856/911] Built Mathlib.Order.CompleteLattice.Basic (11s)
✔ [857/911] Built Mathlib.Algebra.Order.Sub.Unbundled.Basic (5.1s)
✔ [858/911] Built Mathlib.Algebra.Order.Monoid.TypeTags (4.0s)
✔ [859/913] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes (4.2s)
✔ [860/913] Built Mathlib.Lean.Meta.Tactic.Rewrite (3.6s)
✔ [861/913] Built Mathlib.Tactic.NormNum.Basic (13s)
✔ [862/915] Built Mathlib.Algebra.Order.AddGroupWithTop (7.1s)
✔ [863/915] Built Mathlib.Order.OmegaCompletePartialOrder (10s)
✔ [864/917] Built Mathlib.Data.Tree.Basic (4.6s)
✔ [865/917] Built Mathlib.Algebra.Field.Rat (7.1s)
✔ [866/917] Built Mathlib.Order.CompleteLattice.Lemmas (6.2s)
✔ [867/920] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm (3.3s)
✔ [868/923] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Gauss (3.4s)
✔ [869/923] Built Mathlib.Tactic.Zify (4.3s)
✔ [870/924] Built Mathlib.Algebra.Order.Sub.Basic (5.6s)
✔ [871/926] Built Mathlib.Util.ElabWithoutMVars (2.6s)
✔ [872/930] Built Mathlib.Algebra.Order.Ring.Unbundled.Basic (9.3s)
✔ [873/933] Built Mathlib.Order.GaloisConnection.Basic (8.6s)
✔ [874/933] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.PositiveVector (2.8s)
✔ [875/933] Built Mathlib.Order.ConditionallyCompleteLattice.Defs (4.2s)
✔ [876/933] Built Mathlib.Data.Rat.Cast.Defs (5.3s)
✔ [877/933] Built Mathlib.Order.ConditionallyCompletePartialOrder.Defs (4.0s)
✔ [878/933] Built Mathlib.Data.Set.Order (4.0s)
✔ [879/936] Built Mathlib.Order.Antichain (4.9s)
✔ [880/938] Built Mathlib.Tactic.NormNum.Pow (8.4s)
✔ [881/940] Built Mathlib.Algebra.Order.Ring.Defs (3.7s)
✔ [882/940] Built Mathlib.Order.Interval.Set.Image (5.7s)
✔ [883/940] Built Mathlib.Order.Hom.Order (3.7s)
✔ [884/940] Built Mathlib.Order.Interval.Set.LinearOrder (6.7s)
✔ [885/941] Built Mathlib.Algebra.Order.Monoid.Basic (3.0s)
✔ [886/941] Built Mathlib.Order.LatticeIntervals (4.5s)
✔ [887/942] Built Mathlib.Order.ConditionallyCompletePartialOrder.Basic (3.6s)
✔ [888/948] Built Mathlib.Data.Rat.Cast.CharZero (4.4s)
✔ [889/948] Built Mathlib.Algebra.Order.GroupWithZero.Canonical (11s)
✔ [890/948] Built Mathlib.Algebra.Order.Positive.Ring (3.7s)
✔ [891/948] Built Mathlib.Algebra.Order.Ring.Canonical (3.8s)
✔ [892/954] Built Mathlib.Algebra.Order.Ring.Rat (3.3s)
✔ [893/955] Built Mathlib.Algebra.Order.Ring.InjSurj (2.7s)
✔ [894/955] Built Mathlib.Algebra.Order.Ring.Nat (3.7s)
✔ [895/956] Built Mathlib.Data.Int.GCD (3.9s)
✔ [896/957] Built Mathlib.Algebra.Order.Group.Abs (4.3s)
✔ [897/957] Built Mathlib.Tactic.CancelDenoms.Core (5.7s)
✔ [898/959] Built Mathlib.Order.Interval.Set.UnorderedInterval (5.1s)
✔ [899/965] Built Mathlib.Order.CompleteBooleanAlgebra (10s)
✔ [900/965] Built Mathlib.Algebra.Notation (2.8s)
✔ [901/966] Built Mathlib.Algebra.Order.Field.Canonical (3.8s)
✔ [902/966] Built Mathlib.Algebra.Order.Hom.Basic (3.3s)
✔ [903/966] Built Mathlib.Tactic.NormNum.Inv (5.7s)
✔ [904/966] Built Mathlib.Data.Int.Cast.Pi (2.1s)
✔ [905/967] Built Mathlib.Data.Int.Cast.Field (2.6s)
✔ [906/967] Built Mathlib.Data.Nat.Cast.Order.Ring (3.6s)
✔ [907/967] Built Mathlib.Algebra.Order.Ring.Basic (4.2s)
✔ [908/970] Built Mathlib.Data.Set.BooleanAlgebra (3.2s)
✔ [909/970] Built Mathlib.Order.Interval.Set.OrderEmbedding (3.8s)
✔ [910/970] Built Mathlib.Algebra.Order.Ring.Int (4.4s)
✔ [911/970] Built Mathlib.Algebra.Notation.Support (4.5s)
✔ [912/971] Built Mathlib.Data.Nat.Factorial.Basic (5.2s)
✔ [913/971] Built Aeneas.Tactic.Simp.SimpScalar.Init (3.1s)
✔ [914/971] Built Aeneas.Tactic.Solver.ScalarTac.Init (4.3s)
✔ [915/971] Built Aeneas.Tactic.Simp.SimpBoolProp.Init (2.7s)
✔ [916/972] Built Mathlib.Tactic.NormNum.Eq (4.0s)
✔ [917/973] Built Mathlib.Algebra.Order.Group.PosPart (5.6s)
✔ [918/973] Built Mathlib.Algebra.Order.Invertible (3.0s)
✔ [919/973] Built Mathlib.Tactic.NormNum.Abs (4.3s)
✔ [920/976] Built Mathlib.Tactic.Linarith.Lemmas (4.3s)
✔ [921/976] Built Aeneas.Tactic.Conv.Bvify.Init (2.7s)
✔ [922/976] Built Mathlib.Data.Set.Lattice.Indexed (4.2s)
✔ [923/976] Built Mathlib.Data.Int.CharZero (3.5s)
✔ [924/977] Built Aeneas.Data.Nat (2.9s)
✔ [925/977] Built Aeneas.Data.Int (2.8s)
✔ [926/981] Built Mathlib.Order.Interval.Set.OrdConnected (4.7s)
✔ [927/981] Built Mathlib.Algebra.Order.Ring.Cast (4.5s)
✔ [928/981] Built Aeneas.Tactic.Simp.SimpLists.Init (3.1s)
✔ [929/983] Built Aeneas.Tactic.Simp.SimpBoolProp.SimpBoolProp (4.0s)
✔ [930/987] Built Mathlib.Algebra.Group.Nat.Units (2.0s)
✔ [931/989] Built Batteries.Data.Fin.Basic (1.3s)
✔ [932/990] Built Mathlib.Algebra.Group.Irreducible.Defs (2.2s)
✔ [933/992] Built Mathlib.Tactic.Linarith.Datatypes (3.9s)
✔ [934/992] Built Aeneas.Std.Scalar.Elab (4.2s)
✔ [935/992] Built Mathlib.Data.Int.DivMod (2.1s)
✔ [936/992] Built Mathlib.Data.Set.Lattice.Bounded (4.6s)
✔ [937/992] Built Mathlib.Algebra.GroupWithZero.Opposite (3.3s)
✔ [938/993] Built Mathlib.Algebra.Prime.Defs (3.9s)
✔ [939/993] Built Mathlib.Order.ConditionallyCompleteLattice.Basic (6.9s)
✔ [940/993] Built Mathlib.Algebra.Group.ULift (3.6s)
✔ [941/993] Built Mathlib.Tactic.NormNum.Ineq (6.6s)
✔ [942/993] Built Mathlib.Tactic.Ring.Common (15s)
✔ [943/996] Built Mathlib.Tactic.Linarith.Parsing (4.3s)
✔ [944/996] Built Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm (4.4s)
✔ [945/996] Built Mathlib.Tactic.Positivity.Core (8.9s)
✔ [946/998] Built Mathlib.Tactic.Linarith.Preprocessing (5.5s)
✔ [947/998] Built Mathlib.Order.BourbakiWitt (4.4s)
✔ [948/998] Built Mathlib.Algebra.Group.ModEq (3.8s)
✔ [949/998] Built Mathlib.Data.Fin.Basic (4.0s)
✔ [950/999] Built Mathlib.Data.Nat.Prime.Defs (4.7s)
✔ [951/999] Built Mathlib.Algebra.Ring.Equiv (7.9s)
✔ [952/999] Built Mathlib.Algebra.Ring.Opposite (6.8s)
✔ [953/999] Built Mathlib.Tactic.NormNum.DivMod (4.0s)
✔ [954/1001] Built Mathlib.Order.CompleteLatticeIntervals (6.1s)
✔ [955/1001] Built Mathlib.Data.Nat.Cast.Prod (2.0s)
✔ [956/1001] Built Mathlib.Data.Nat.GCD.Basic (5.1s)
✔ [957/1001] Built Mathlib.Algebra.GroupWithZero.Units.Equiv (4.4s)
✔ [958/1002] Built Mathlib.Order.FixedPoints (6.5s)
✔ [959/1002] Built Mathlib.Algebra.Group.Int.Units (3.9s)
✔ [960/1002] Built Mathlib.Tactic.Linarith.Verification (7.8s)
✔ [961/1006] Built Mathlib.Algebra.CharP.Defs (5.5s)
✔ [962/1006] Built Mathlib.Algebra.Order.Nonneg.Lattice (5.7s)
✔ [963/1006] Built Mathlib.Tactic.Ring.Basic (12s)
✔ [964/1006] Built Mathlib.Algebra.Ring.ULift (7.7s)
✔ [965/1006] Built Mathlib.Data.Fin.SuccPred (8.8s)
✔ [966/1006] Built Mathlib.Algebra.Ring.Int.Units (3.4s)
✔ [967/1016] Built Mathlib.Data.ENat.Defs (2.5s)
✔ [968/1016] Built Aeneas.Data.Coinductive.ITreeWP.FunctionalWP (4.5s)
✔ [969/1016] Built Mathlib.Algebra.Order.Sub.WithTop (3.4s)
✔ [970/1016] Built Mathlib.Data.Nat.ModEq (5.8s)
✔ [971/1016] Built Mathlib.Algebra.Order.Nonneg.Ring (4.4s)
✔ [972/1016] Built Mathlib.Data.Fin.Rev (3.8s)
✔ [973/1016] Built Mathlib.Order.Interval.Set.WithBotTop (3.8s)
✔ [974/1016] Built Mathlib.Data.ENat.Basic (3.8s)
✔ [975/1020] Built Aeneas.Data.Coinductive.ITreeWP.DWLP (4.3s)
✔ [976/1020] Built Mathlib.Tactic.Ring.RingNF (5.7s)
✔ [977/1021] Built Aeneas.Data.Coinductive.ITreeWP.DWP (4.2s)
✔ [978/1022] Built Mathlib.Tactic.Linarith.Frontend (6.4s)
✔ [979/1022] Built Mathlib.Algebra.Order.Ring.WithTop (9.8s)
✔ [980/1027] Built Aeneas.Data.Coinductive.ITreeWP.Taxonomy (810ms)
✔ [981/1027] Built Mathlib.Control.Functor (2.2s)
✔ [982/1027] Built Mathlib.Algebra.Group.Fin.Basic (3.9s)
✔ [983/1027] Built Mathlib.Data.List.Monad (2.4s)
✔ [984/1027] Built Mathlib.Data.Int.ModEq (5.1s)
✔ [985/1028] Built Batteries.Data.List.Perm (2.0s)
✔ [986/1033] Built Aeneas.Data.Coinductive.ITreeWP.Tests (1.9s)
✔ [987/1036] Built Mathlib.Tactic.Positivity.Basic (21s)
✔ [988/1037] Built Mathlib.Algebra.Order.Nonneg.Field (6.9s)
✔ [989/1037] Built Aeneas.Data.Coinductive.ITreeWP (1.5s)
✔ [990/1038] Built Mathlib.Data.List.InsertIdx (4.7s)
✔ [991/1038] Built Mathlib.Data.List.Forall2 (5.3s)
✔ [992/1040] Built Mathlib.Data.List.Defs (4.3s)
✔ [993/1040] Built Mathlib.Data.ENat.Monoid (6.5s)
✔ [994/1046] Built Mathlib.Data.List.Count (4.4s)
✔ [995/1053] Built Mathlib.Algebra.CharP.Basic (5.1s)
✔ [996/1053] Built Mathlib.Data.Finset.Attr (2.7s)
✔ [997/1064] Built Mathlib.Order.Cover (9.6s)
✔ [998/1069] Built Mathlib.Algebra.Order.Field.Rat (3.5s)
✔ [999/1069] Built Mathlib.Data.Set.List (2.6s)
✔ [1000/1076] Built Mathlib.Tactic.NormNum.OfScientific (4.0s)
✔ [1001/1084] Built Mathlib.Data.List.Perm.Basic (3.7s)
✔ [1002/1085] Built Mathlib.Basic.Finite.Defs (2.3s)
✔ [1003/1089] Built Mathlib.Data.List.Induction (2.8s)
✔ [1004/1092] Built Batteries.Data.Fin.Lemmas (2.3s)
✔ [1005/1093] Built Mathlib.Basic.Countable.Defs (2.7s)
✔ [1006/1093] Built Mathlib.Logic.Small.Defs (2.4s)
✔ [1007/1093] Built Mathlib.Data.List.Basic (6.4s)
✔ [1008/1093] Built Mathlib.Data.List.TakeDrop (5.5s)
✔ [1009/1093] Built Mathlib.Data.Fin.Embedding (4.5s)
✔ [1010/1093] Built Mathlib.Algebra.BigOperators.Group.List.Defs (2.3s)
✔ [1011/1093] Built Aeneas.Std.WP (8.7s)
✔ [1012/1093] Built Mathlib.Basic.UnivLE (2.2s)
✔ [1013/1093] Built Mathlib.Data.List.Flatten (2.6s)
✔ [1014/1093] Built Mathlib.Data.Rat.Cast.Order (6.7s)
✔ [1015/1096] Built Mathlib.Logic.Small.Basic (2.0s)
✔ [1016/1096] Built Mathlib.Order.SuccPred.Basic (8.3s)
✔ [1017/1096] Built Mathlib.Data.List.ProdSigma (3.6s)
✔ [1018/1098] Built Mathlib.Data.List.Infix (3.9s)
✔ [1019/1098] Built Mathlib.Algebra.Order.Hom.Monoid (8.2s)
✔ [1020/1099] Built Mathlib.Data.List.Lattice (4.7s)
✔ [1021/1099] Built Mathlib.Data.List.Perm.Subperm (4.0s)
✔ [1022/1104] Built Mathlib.Tactic.NormNum (4.6s)
✔ [1023/1104] Built Mathlib.Data.List.Nodup (6.6s)
✔ [1024/1104] Built Mathlib.Order.Fin.Basic (5.0s)
✔ [1025/1104] Built Mathlib.Basic.Countable.Small (3.9s)
✔ [1026/1104] Built Aeneas.Tactic.Step.PrepareIntroOutputs (6.4s)
✔ [1027/1104] Built Mathlib.Data.List.Lex (4.0s)
✔ [1028/1104] Built Mathlib.Order.SuccPred.WithBot (4.5s)
✔ [1029/1104] Built Mathlib.Algebra.BigOperators.Group.List.Basic (7.6s)
✔ [1030/1104] Built Mathlib.Order.SuccPred.Archimedean (5.1s)
✔ [1031/1104] Built Mathlib.Data.List.Dedup (3.1s)
✔ [1032/1106] Built Mathlib.Data.Multiset.Defs (3.8s)
✔ [1033/1106] Built Aeneas.Command.Decompose (8.8s)
✔ [1034/1106] Built Mathlib.Data.List.Perm.Lattice (3.5s)
✔ [1035/1110] Built Mathlib.Data.List.Duplicate (3.2s)
✔ [1036/1110] Built Mathlib.Data.List.Rotate (4.2s)
✔ [1037/1113] Built Mathlib.Algebra.Order.Hom.MonoidWithZero (5.5s)
✔ [1038/1116] Built Mathlib.Tactic.Linarith (4.6s)
✔ [1039/1116] Built Aeneas.Tactic.Step.SpecInfo (4.4s)
✔ [1040/1116] Built Mathlib.Data.List.Enum (3.8s)
✔ [1041/1117] Built Mathlib.Data.Finset.Defs (4.7s)
✔ [1042/1117] Built Mathlib.Data.Fin.Tuple.Basic (7.2s)
✔ [1043/1117] Built Mathlib.Data.List.Chain (5.7s)
✔ [1044/1118] Built Mathlib.Data.Multiset.ZeroCons (5.5s)
✔ [1045/1118] Built Mathlib.Data.Set.Piecewise (3.6s)
✔ [1046/1121] Built Mathlib.Data.Nat.Choose.Basic (5.1s)
✔ [1047/1121] Built Mathlib.Algebra.Order.Hom.Ring (5.7s)
✔ [1048/1121] Built Mathlib.Order.SuccPred.Limit (7.8s)
✔ [1049/1122] Built Mathlib.Data.List.Range (2.7s)
✔ [1050/1122] Built Mathlib.Data.List.OfFn (3.3s)
✔ [1051/1122] Built Mathlib.Data.List.FinRange (3.3s)
✔ [1052/1122] Built Mathlib.Data.List.OffDiag (3.0s)
✔ [1053/1123] Built Mathlib.Data.Finset.Empty (3.2s)
✔ [1054/1127] Built Aeneas.Tactic.Solver.ScalarTac.Core (5.6s)
✔ [1055/1128] Built Mathlib.Data.Multiset.Count (3.1s)
✔ [1056/1128] Built Mathlib.Data.Multiset.Basic (3.2s)
✔ [1057/1132] Built Mathlib.Algebra.BigOperators.Group.List.Lemmas (3.7s)
✔ [1058/1132] Built Mathlib.Algebra.Order.SuccPred (4.9s)
✔ [1059/1137] Built Mathlib.Order.Hom.Bounded (6.2s)
✔ [1060/1141] Built Mathlib.Data.Set.Sigma (5.2s)
✔ [1061/1143] Built Mathlib.Order.Hom.Lattice (6.3s)
✔ [1062/1144] Built Mathlib.Data.List.Sort (5.8s)
✔ [1063/1144] Built Mathlib.Data.Set.Lattice.Image (5.8s)
✔ [1064/1148] Built Mathlib.Data.Multiset.AddSub (5.0s)
✔ [1065/1148] Built Aeneas.Tactic.Step.Init (11s)
✔ [1066/1148] Built Mathlib.Control.Applicative (2.3s)
✔ [1067/1148] Built Mathlib.Logic.Function.DependsOn (2.9s)
✔ [1068/1148] Built Mathlib.Control.Traversable.Basic (2.3s)
✔ [1069/1148] Built Mathlib.Logic.Embedding.Set (4.7s)
✔ [1070/1149] Built Mathlib.Order.SuccPred.Nat (3.9s)
✔ [1071/1150] Built Mathlib.Data.Vector.Defs (3.8s)
✔ [1072/1152] Built Mathlib.Order.Setoid.Basic (5.3s)
✔ [1073/1152] Built Mathlib.Data.List.NodupEquivFin (5.6s)
✔ [1074/1156] Built Mathlib.Data.Multiset.Replicate (5.5s)
✔ [1075/1156] Built Aeneas.Tactic.Solver.ScalarTac.ScalarTac (13s)
✔ [1076/1160] Built Mathlib.Tactic.ApplyFun (5.9s)
✔ [1077/1160] Built Mathlib.Order.SuccPred.ENat (6.3s)
✔ [1078/1160] Built Aeneas.Std.Core.Cmp (6.8s)
✔ [1079/1161] Built Aeneas.Std.Core.Core (6.9s)
✔ [1080/1161] Built Mathlib.Order.Hom.BoundedLattice (9.5s)
✔ [1081/1161] Built Mathlib.Data.Nat.Bits (2.8s)
✔ [1082/1162] Built Mathlib.Data.List.Zip (4.4s)
✔ [1083/1162] Built Mathlib.Data.Set.Lattice.Disjoint (4.2s)
✔ [1084/1166] Built Mathlib.Data.List.Sublists (5.5s)
✔ [1085/1166] Built Mathlib.Data.Vector.Basic (7.7s)
✔ [1086/1170] Built Mathlib.Data.Nat.Pairing (3.5s)
✔ [1087/1170] Built Mathlib.Data.ENat.Pow (4.3s)
✔ [1088/1170] Built Mathlib.Data.Multiset.MapFold (5.0s)
✔ [1089/1170] Built Mathlib.Data.Nat.Order.Lemmas (2.7s)
✔ [1090/1170] Built Mathlib.Data.PNat.Equiv (2.4s)
✔ [1091/1172] Built Aeneas.Std.Core.Convert (5.5s)
✔ [1092/1174] Built Mathlib.Data.Set.Pairwise.Lattice (3.7s)
✔ [1093/1176] Built Aeneas.Std.Alloc.Alloc (4.8s)
✔ [1094/1176] Built Mathlib.Logic.Equiv.Nat (2.9s)
✔ [1095/1176] Built Mathlib.Logic.Small.Set (3.9s)
✔ [1096/1176] Built Mathlib.Data.List.MinMax (7.1s)
✔ [1097/1176] Built Mathlib.Data.Finset.Attach (4.5s)
✔ [1098/1180] Built Mathlib.Order.Minimal (7.1s)
✔ [1099/1180] Built Mathlib.Order.RelIso.Set (4.3s)
✔ [1100/1189] Built Mathlib.Data.Multiset.Filter (5.6s)
✔ [1101/1189] Built Mathlib.Order.Prod.Lex.Basic (6.6s)
✔ [1102/1189] Built Mathlib.Basic.Countable.Basic (4.7s)
✔ [1103/1189] Built Mathlib.Logic.Encodable.Basic (5.2s)
✔ [1104/1189] Built Mathlib.SetTheory.Cardinal.Defs (3.8s)
✔ [1105/1191] Built Aeneas.Std.Alloc.Boxed (6.4s)
✔ [1106/1191] Built Mathlib.Order.ConditionallyCompletePartialOrder.Indexed (4.4s)
✔ [1107/1193] Built Mathlib.Algebra.BigOperators.Group.Multiset.Defs (4.2s)
✔ [1108/1193] Built Mathlib.Order.Sum.Order (9.1s)
✔ [1109/1193] Built Mathlib.Order.UpperLower.Basic (8.7s)
✔ [1110/1194] Built Aeneas.Std.Scalar.Core (16s)
✔ [1111/1197] Built Mathlib.Data.Finset.Filter (4.1s)
✔ [1112/1197] Built Mathlib.Order.CompleteLattice.Chain (2.6s)
✔ [1113/1200] Built Mathlib.Data.Finset.Erase (3.2s)
✔ [1114/1201] Built Mathlib.Algebra.GroupWithZero.Prod (2.0s)
✔ [1115/1204] Built Mathlib.Data.Int.Cast.Prod (2.4s)
✔ [1116/1211] Built Mathlib.Algebra.Ring.CompTypeclasses (3.1s)
✔ [1117/1211] Built Mathlib.Data.Multiset.UnionInter (4.3s)
✔ [1118/1211] Built Mathlib.Order.Hom.Lex (4.2s)
✔ [1119/1216] Built Mathlib.Order.Zorn (2.0s)
✔ [1120/1216] Built Mathlib.Algebra.Group.Subsemigroup.Defs (3.9s)
✔ [1121/1216] Built Mathlib.Algebra.Group.Action.Defs (4.5s)
✔ [1122/1216] Built Mathlib.Order.ConditionallyCompleteLattice.Indexed (6.4s)
✔ [1123/1218] Built Mathlib.Data.Fintype.Defs (4.4s)
✔ [1124/1218] Built Mathlib.Algebra.Group.Conj (4.2s)
✔ [1125/1218] Built Mathlib.Data.Multiset.Dedup (3.4s)
✔ [1126/1218] Built Mathlib.Data.Multiset.Range (3.1s)
✔ [1127/1220] Built Mathlib.Algebra.Ring.Prod (5.5s)
✔ [1128/1220] Built Mathlib.Algebra.Group.Action.Faithful (2.3s)
✔ [1129/1220] Built Mathlib.Algebra.Group.Pi.Lemmas (6.3s)
✔ [1130/1220] Built Mathlib.Algebra.Group.Subsemigroup.Basic (3.4s)
✔ [1131/1220] Built Mathlib.SetTheory.Cardinal.SchroederBernstein (3.0s)
✔ [1132/1220] Built Mathlib.Algebra.Group.Action.Opposite (3.2s)
✔ [1133/1222] Built Mathlib.Order.InitialSeg (5.2s)
✔ [1134/1222] Built Mathlib.Algebra.Group.Submonoid.Defs (4.6s)
✔ [1135/1224] Built Mathlib.Data.Multiset.Fold (2.8s)
✔ [1136/1224] Built Mathlib.Data.Finset.Dedup (3.4s)
✔ [1137/1224] Built Mathlib.Order.SuccPred.CompleteLinearOrder (4.2s)
✔ [1138/1224] Built Mathlib.Algebra.Order.Group.Multiset (3.2s)
✔ [1139/1224] Built Mathlib.Logic.Function.CompTypeclasses (1.8s)
✔ [1140/1224] Built Mathlib.Data.Multiset.FinsetOps (3.3s)
✔ [1141/1224] Built Mathlib.Algebra.Group.Center (7.5s)
✔ [1142/1224] Built Mathlib.Algebra.Group.Action.Units (3.2s)
✔ [1143/1224] Built Mathlib.Algebra.Group.Pointwise.Set.Scalar (3.9s)
✔ [1144/1224] Built Mathlib.Algebra.GroupWithZero.Action.Defs (3.5s)
✔ [1145/1224] Built Mathlib.Algebra.Group.Submonoid.MulAction (2.8s)
✔ [1146/1224] Built Mathlib.Algebra.Regular.SMul (2.7s)
✔ [1147/1224] Built Mathlib.Algebra.Group.Hom.CompTypeclasses (2.0s)
✔ [1148/1227] Built Mathlib.Algebra.Group.Submonoid.Basic (3.8s)
✔ [1149/1227] Built Mathlib.Data.Multiset.Sum (3.2s)
✔ [1150/1227] Built Mathlib.Algebra.BigOperators.Group.Multiset.Basic (4.3s)
✔ [1151/1232] Built Mathlib.Data.Sym.Basic (4.0s)
✔ [1152/1232] Built Mathlib.Data.Multiset.Lattice (4.0s)
✔ [1153/1232] Built Mathlib.GroupTheory.Subsemigroup.Center (2.9s)
✔ [1154/1233] Built Mathlib.Data.Finset.Insert (5.1s)
✔ [1155/1233] Built Mathlib.Data.Finset.Lattice.Basic (4.2s)
✔ [1156/1235] Built Mathlib.Algebra.Group.Action.Basic (3.7s)
✔ [1157/1235] Built Mathlib.Algebra.Group.Submonoid.DistribMulAction (3.1s)
✔ [1158/1235] Built Mathlib.Algebra.Module.Defs (3.7s)
✔ [1159/1236] Built Mathlib.Algebra.Group.Subgroup.Defs (7.5s)
✔ [1160/1236] Built Mathlib.Algebra.Group.Action.TypeTags (2.6s)
✔ [1161/1239] Built Mathlib.Algebra.GroupWithZero.Action.Units (2.8s)
✔ [1162/1240] Built Mathlib.Data.Multiset.Bind (3.7s)
✔ [1163/1240] Built Mathlib.Data.Finset.Range (3.3s)
✔ [1164/1240] Built Mathlib.Data.Finset.Disjoint (3.4s)
✔ [1165/1247] Built Mathlib.Data.Finset.Lattice.Lemmas (3.4s)
✔ [1166/1249] Built Mathlib.Data.Finset.SDiff (3.8s)
✔ [1167/1249] Built Mathlib.Algebra.Group.Support (2.0s)
✔ [1168/1249] Built Mathlib.Algebra.Group.Action.Pretransitive (2.7s)
✔ [1169/1249] Built Mathlib.Algebra.Group.Commute.Hom (2.5s)
✔ [1170/1257] Built Mathlib.Algebra.Order.Group.Action (3.0s)
✔ [1171/1264] Built Mathlib.Data.Multiset.Powerset (4.0s)
✔ [1172/1264] Built Mathlib.GroupTheory.GroupAction.Defs (6.2s)
✔ [1173/1264] Built Mathlib.Data.Multiset.Pi (4.1s)
✔ [1174/1265] Built Mathlib.Algebra.Ring.Divisibility.Basic (3.7s)
✔ [1175/1267] Built Mathlib.Algebra.Group.Action.Hom (3.6s)
✔ [1176/1267] Built Mathlib.Algebra.Group.Submonoid.Operations (11s)
✔ [1177/1267] Built Mathlib.Data.Finset.Basic (5.2s)
✔ [1178/1268] Built Mathlib.Data.Finset.Image (5.6s)
✔ [1179/1268] Built Mathlib.Algebra.Group.Irreducible.Lemmas (3.4s)
✔ [1180/1268] Built Mathlib.Dynamics.FixedPoints.Basic (3.8s)
✔ [1181/1268] Built Mathlib.Data.List.Permutation (4.3s)
✔ [1182/1268] Built Mathlib.Algebra.GroupWithZero.Action.End (2.7s)
✔ [1183/1268] Built Mathlib.Data.PNat.Basic (4.8s)
✔ [1184/1268] Built Mathlib.Algebra.Group.Embedding (2.7s)
✔ [1185/1268] Built Mathlib.Algebra.Order.Ring.Abs (4.5s)
✔ [1186/1276] Built Mathlib.Algebra.Group.Pointwise.Set.Basic (13s)
✔ [1187/1278] Built Mathlib.Data.Finset.BooleanAlgebra (3.8s)
✔ [1188/1278] Built Mathlib.GroupTheory.Submonoid.Center (4.2s)
✔ [1189/1279] Built Mathlib.Data.Fintype.OfMap (3.2s)
✔ [1190/1279] Built Mathlib.Data.Finset.SymmDiff (3.3s)
✔ [1191/1279] Built Mathlib.Data.Finset.Fold (3.6s)
✔ [1192/1283] Built Mathlib.Algebra.Ring.Action.Basic (2.5s)
✔ [1193/1284] Built Mathlib.Algebra.Prime.Lemmas (3.7s)
✔ [1194/1284] Built Mathlib.Algebra.Group.Subgroup.Lattice (7.7s)
✔ [1195/1284] Built Mathlib.Algebra.Notation.Indicator (3.9s)
✔ [1196/1285] Built Mathlib.Data.Finset.Piecewise (4.2s)
✔ [1197/1288] Built Mathlib.Algebra.Group.Pointwise.Set.Lattice (4.7s)
✔ [1198/1289] Built Mathlib.Data.Fintype.Sets (4.8s)
✔ [1199/1289] Built Mathlib.Order.Hom.WithTopBot (5.9s)
✔ [1200/1289] Built Mathlib.Data.Finset.Union (5.1s)
✔ [1201/1290] Built Mathlib.Data.Finset.Card (8.3s)
✔ [1202/1290] Built Mathlib.Algebra.Group.Subsemigroup.MulOpposite (3.9s)
✔ [1203/1290] Built Mathlib.Algebra.GroupWithZero.Associated (4.7s)
✔ [1204/1290] Built Mathlib.Algebra.Group.Idempotent (2.5s)
✔ [1205/1290] Built Mathlib.Algebra.Group.Action.Pointwise.Set.Basic (4.9s)
✔ [1206/1290] Built Mathlib.Algebra.Order.BigOperators.Group.List (4.2s)
✔ [1207/1290] Built Mathlib.Data.Finset.Pi (4.0s)
✔ [1208/1290] Built Mathlib.Data.Fintype.Basic (4.2s)
✔ [1209/1294] Built Mathlib.Algebra.FreeMonoid.Basic (5.5s)
✔ [1210/1294] Built Mathlib.Data.Finset.Option (3.7s)
✔ [1211/1294] Built Mathlib.Algebra.Group.Subgroup.Map (7.0s)
✔ [1212/1294] Built Mathlib.Order.Sigma.Lex (2.9s)
✔ [1213/1294] Built Mathlib.Data.Finset.Sum (5.2s)
✔ [1214/1294] Built Mathlib.Algebra.Group.Submonoid.MulOpposite (4.5s)
✔ [1215/1295] Built Mathlib.Data.Finset.Prod (5.8s)
✔ [1216/1295] Built Mathlib.Algebra.Ring.Associated (4.0s)
✔ [1217/1295] Built Mathlib.Algebra.BigOperators.Group.Finset.Defs (9.1s)
✔ [1218/1296] Built Mathlib.Data.Nat.Prime.Basic (4.9s)
✔ [1219/1296] Built Mathlib.Algebra.Group.Submonoid.Finite (5.5s)
✔ [1220/1296] Built Mathlib.Data.Fintype.Card (5.9s)
✔ [1221/1296] Built Mathlib.Algebra.Group.TransferInstance (6.6s)
✔ [1222/1296] Built Mathlib.Order.CompleteLattice.Finset (7.2s)
✔ [1223/1296] Built Mathlib.Algebra.Group.Subgroup.ZPowers.Basic (6.2s)
✔ [1224/1301] Built Mathlib.Algebra.Group.Subgroup.MulOpposite (6.0s)
✔ [1225/1307] Built Mathlib.Algebra.Group.Action.End (6.2s)
✔ [1226/1307] Built Mathlib.GroupTheory.GroupAction.Hom (20s)
✔ [1227/1311] Built Mathlib.Algebra.CharP.Two (5.2s)
✔ [1228/1315] Built Mathlib.Algebra.Group.Commutator (2.5s)
✔ [1229/1316] Built Mathlib.GroupTheory.Subsemigroup.Centralizer (3.6s)
✔ [1230/1316] Built Mathlib.Algebra.GroupWithZero.Pointwise.Set.Basic (3.5s)
✔ [1231/1320] Built Mathlib.Algebra.Group.Subgroup.Ker (11s)
✔ [1232/1320] Built Mathlib.Data.Fintype.EquivFin (5.5s)
✔ [1233/1320] Built Mathlib.Algebra.Group.Action.Prod (4.8s)
✔ [1234/1320] Built Mathlib.Data.Finset.Lattice.Fold (12s)
✔ [1235/1324] Built Mathlib.Algebra.Quotient (4.4s)
✔ [1236/1324] Built Mathlib.GroupTheory.Submonoid.Centralizer (4.1s)
✔ [1237/1324] Built Mathlib.Algebra.GroupWithZero.Action.Opposite (3.1s)
✔ [1238/1324] Built Mathlib.Algebra.Regular.Opposite (2.9s)
✔ [1239/1324] Built Mathlib.Algebra.Module.NatInt (4.0s)
✔ [1240/1324] Built Mathlib.Algebra.GCDMonoid.Basic (13s)
✔ [1241/1324] Built Mathlib.GroupTheory.Congruence.Defs (7.8s)
✔ [1242/1326] Built Mathlib.Data.Fintype.Prod (4.3s)
✔ [1243/1326] Built Mathlib.Data.Fintype.Option (3.9s)
✔ [1244/1326] Built Mathlib.Data.Fintype.Sum (4.4s)
✔ [1245/1326] Built Mathlib.Algebra.BigOperators.Group.Finset.Basic (13s)
✔ [1246/1326] Built Mathlib.Basic.Denumerable (4.5s)
✔ [1247/1326] Built Mathlib.Algebra.GroupWithZero.Action.Basic (3.7s)
✔ [1248/1326] Built Mathlib.Algebra.Group.Submonoid.Membership (7.6s)
✔ [1249/1326] Built Mathlib.Data.ZMod.Defs (4.6s)
✔ [1250/1326] Built Mathlib.Data.Set.Finite.Basic (5.9s)
✔ [1251/1326] Built Mathlib.Logic.Equiv.Sigma (3.5s)
✔ [1252/1326] Built Mathlib.Data.Finset.Lattice.Union (4.4s)
✔ [1253/1326] Built Mathlib.Data.Finset.Sigma (5.1s)
✔ [1254/1326] Built Mathlib.Data.Finset.Max (7.1s)
✔ [1255/1326] Built Mathlib.Algebra.Module.Opposite (3.7s)
✔ [1256/1326] Built Mathlib.Algebra.GCDMonoid.Nat (4.4s)
✔ [1257/1327] Built Mathlib.Algebra.Group.Subgroup.Basic (13s)
✔ [1258/1327] Built Mathlib.Algebra.GCDMonoid.Multiset (4.4s)
✔ [1259/1327] Built Mathlib.GroupTheory.Coset.Defs (5.8s)
✔ [1260/1329] Built Mathlib.Algebra.BigOperators.GroupWithZero.Finset (3.6s)
✔ [1261/1329] Built Mathlib.GroupTheory.Congruence.Hom (4.8s)
✔ [1262/1329] Built Mathlib.Algebra.BigOperators.Option (3.6s)
✔ [1263/1329] Built Mathlib.SetTheory.Cardinal.Order (5.3s)
✔ [1264/1329] Built Mathlib.Logic.Equiv.List (3.9s)
✔ [1265/1329] Built Mathlib.Data.Finset.NoncommProd (5.4s)
✔ [1266/1329] Built Mathlib.Data.Fintype.Pi (4.5s)
✔ [1267/1329] Built Mathlib.Data.Set.Finite.Range (4.4s)
✔ [1268/1329] Built Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set (4.5s)
✔ [1269/1329] Built Mathlib.Algebra.BigOperators.Group.Finset.Piecewise (5.0s)
✔ [1270/1329] Built Mathlib.Order.Preorder.Finite (4.2s)
✔ [1271/1329] Built Mathlib.Data.Finset.Powerset (4.8s)
✔ [1272/1329] Built Mathlib.Algebra.Module.Torsion.Free (4.2s)
✔ [1273/1330] Built Mathlib.Algebra.BigOperators.Group.Finset.Sigma (3.9s)
✔ [1274/1330] Built Mathlib.Data.Finset.Preimage (3.7s)
✔ [1275/1330] Built Mathlib.Algebra.GCDMonoid.Finset (4.0s)
✔ [1276/1330] Built Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas (4.2s)
✔ [1277/1332] Built Mathlib.Data.Fintype.Sigma (4.6s)
✔ [1278/1332] Built Mathlib.Data.Nat.Log (4.1s)
✔ [1279/1332] Built Mathlib.GroupTheory.Subgroup.Center (4.7s)
✔ [1280/1332] Built Mathlib.Data.Nat.Prime.Pow (3.1s)
✔ [1281/1332] Built Mathlib.Algebra.Group.Submonoid.BigOperators (3.9s)
✔ [1282/1332] Built Mathlib.Basic.Finite.Prod (3.6s)
✔ [1283/1332] Built Mathlib.Data.Set.Countable (3.2s)
✔ [1284/1332] Built Mathlib.Data.Fintype.List (3.0s)
✔ [1285/1332] Built Mathlib.Data.Fintype.Powerset (3.2s)
✔ [1286/1335] Built Mathlib.Data.Set.Finite.Powerset (3.3s)
✔ [1287/1335] Built Mathlib.GroupTheory.Coset.Basic (7.1s)
✔ [1288/1335] Built Mathlib.Algebra.Order.BigOperators.Group.Multiset (3.7s)
✔ [1289/1335] Built Mathlib.GroupTheory.QuotientGroup.Defs (6.0s)
✔ [1290/1336] Built Mathlib.Basic.Finite.Sigma (2.9s)
✔ [1291/1336] Built Mathlib.Algebra.Order.Monoid.Multiset (2.9s)
✔ [1292/1337] Built Mathlib.Algebra.Group.Subgroup.Actions (3.4s)
✔ [1293/1337] Built Mathlib.Algebra.IsPrimePow (3.0s)
✔ [1294/1340] Built Mathlib.Data.Fintype.Vector (3.0s)
✔ [1295/1340] Built Mathlib.Algebra.Group.Pointwise.Set.Finite (3.8s)
✔ [1296/1341] Built Mathlib.GroupTheory.Subgroup.Centralizer (4.5s)
✔ [1297/1343] Built Mathlib.Algebra.Ring.CharZero (3.6s)
✔ [1298/1343] Built Mathlib.Order.Interval.Set.SuccPred (4.2s)
✔ [1299/1343] Built Mathlib.Order.Interval.Finset.Defs (8.7s)
✔ [1300/1346] Built Mathlib.Data.List.Cycle (5.9s)
✔ [1301/1346] Built Mathlib.Data.List.NatAntidiagonal (3.5s)
✔ [1302/1346] Built Mathlib.Data.Set.Finite.Lattice (6.1s)
✔ [1303/1346] Built Mathlib.Data.Fintype.BigOperators (4.7s)
✔ [1304/1348] Built Mathlib.Algebra.BigOperators.Ring.List (3.5s)
✔ [1305/1348] Built Mathlib.GroupTheory.GroupAction.Basic (6.2s)
✔ [1306/1350] Built Mathlib.GroupTheory.GroupAction.ConjAct (4.8s)
✔ [1307/1350] Built Mathlib.Algebra.Order.BigOperators.Group.Finset (7.5s)
✔ [1308/1350] Built Mathlib.Data.List.Prime (3.7s)
✔ [1309/1350] Built Mathlib.Order.Interval.Finset.SuccPred (4.3s)
✔ [1310/1350] Built Mathlib.Algebra.Order.Antidiag.Prod (5.2s)
✔ [1311/1350] Built Mathlib.Data.Multiset.NatAntidiagonal (3.7s)
✔ [1312/1351] Built Mathlib.GroupTheory.GroupAction.SubMulAction (11s)
✔ [1313/1351] Built Mathlib.Data.Nat.Prime.Infinite (4.1s)
✔ [1314/1351] Built Mathlib.Dynamics.PeriodicPts.Defs (4.9s)
✔ [1315/1351] Built Mathlib.GroupTheory.Commutator.Basic (9.4s)
✔ [1316/1358] Built Mathlib.Order.Interval.Set.Infinite (4.3s)
✔ [1317/1358] Built Mathlib.Tactic.FinCases (5.3s)
✔ [1318/1358] Built Mathlib.Order.Interval.Finset.Basic (9.7s)
✔ [1319/1361] Built Mathlib.Order.ConditionallyCompleteLattice.Finset (7.0s)
✔ [1320/1361] Built Aeneas.Tactic.Simproc.ReduceZMod.Init (4.7s)
✔ [1321/1362] Built Mathlib.SetTheory.Cardinal.Basic (9.2s)
✔ [1322/1362] Built Mathlib.Data.Nat.Factors (5.5s)
✔ [1323/1365] Built Mathlib.Data.Finset.NatAntidiagonal (5.0s)
✔ [1324/1366] Built Mathlib.Algebra.Module.RingHom (4.5s)
✔ [1325/1371] Built Mathlib.Algebra.Order.Interval.Finset.SuccPred (6.4s)
✔ [1326/1371] Built Mathlib.Algebra.EuclideanDomain.Defs (4.0s)
✔ [1327/1375] Built Mathlib.Order.Interval.Multiset (4.9s)
✔ [1328/1375] Built Mathlib.Data.Nat.Prime.Int (4.1s)
✔ [1329/1375] Built Mathlib.Algebra.Group.PUnit (2.8s)
✔ [1330/1375] Built Mathlib.Algebra.GroupWithZero.Action.Regular (3.5s)
✔ [1331/1375] Built Mathlib.Data.Nat.PrimeFin (4.5s)
✔ [1332/1375] Built Mathlib.SetTheory.Cardinal.ENat (5.7s)
✔ [1333/1375] Built Mathlib.GroupTheory.GroupAction.Quotient (10s)
✔ [1334/1375] Built Mathlib.Algebra.EuclideanDomain.Int (2.7s)
✔ [1335/1377] Built Mathlib.Algebra.EuclideanDomain.Field (3.3s)
✔ [1336/1379] Built Mathlib.Algebra.Ring.PUnit (3.3s)
✔ [1337/1390] Built Aeneas.Tactic.Solver.ScalarTac.CondSimpTac (11s)
✔ [1338/1390] Built Mathlib.Algebra.EuclideanDomain.Basic (5.8s)
✔ [1339/1391] Built Mathlib.Algebra.Module.Submodule.Defs (8.1s)
✔ [1340/1392] Built Mathlib.Order.Interval.Finset.Nat (6.6s)
✔ [1341/1392] Built Mathlib.Algebra.GroupWithZero.Idempotent (4.6s)
✔ [1342/1393] Built Mathlib.SetTheory.Cardinal.ToNat (7.2s)
✔ [1343/1393] Built Mathlib.Algebra.Module.PUnit (4.9s)
✔ [1344/1394] Built Mathlib.Tactic.Abel (9.9s)
✔ [1345/1394] Built Mathlib.Algebra.GroupWithZero.Action.Prod (4.8s)
✔ [1346/1394] Built Mathlib.Algebra.GroupWithZero.NonZeroDivisors (8.7s)
✔ [1347/1394] Built Mathlib.Algebra.Module.Submodule.Basic (4.0s)
✔ [1348/1394] Built Mathlib.Order.Lattice.Nat (5.1s)
✔ [1349/1397] Built Mathlib.Algebra.Ring.Idempotent (2.9s)
✔ [1350/1398] Built Mathlib.Order.Hom.CompleteLattice (7.4s)
✔ [1351/1398] Built Mathlib.Basic.Finite.Set (3.3s)
✔ [1352/1398] Built Mathlib.Data.Finset.Order (3.2s)
✔ [1353/1401] Built Mathlib.Algebra.Module.LinearMap.Defs (18s)
✔ [1354/1401] Built Mathlib.RingTheory.Ideal.Defs (5.1s)
✔ [1355/1403] Built Mathlib.SetTheory.Cardinal.Finite (5.7s)
✔ [1356/1404] Built Mathlib.Algebra.Module.Prod (3.6s)
✔ [1357/1404] Built Mathlib.Data.Set.Lattice.Order (4.2s)
✔ [1358/1404] Built Mathlib.Data.Set.Monotone (3.0s)
✔ [1359/1404] Built Mathlib.Dynamics.PeriodicPts.Lemmas (4.9s)
✔ [1360/1406] Built Mathlib.Order.Interval.Set.OrderIso (4.3s)
✔ [1361/1406] Built Mathlib.Order.OrderIsoNat (5.1s)
✔ [1362/1411] Built Mathlib.Data.Finset.Lattice.Prod (4.2s)
✔ [1363/1411] Built Mathlib.Order.Closure (4.0s)
✔ [1364/1411] Built Mathlib.Algebra.Algebra.Defs (4.9s)
✔ [1365/1414] Built Mathlib.NumberTheory.Divisors (13s)
✔ [1366/1416] Built Mathlib.Algebra.Module.Torsion.Field (3.3s)
✔ [1367/1418] Built Mathlib.Algebra.GroupWithZero.Units.Fintype (3.9s)
✔ [1368/1420] Built Mathlib.GroupTheory.Coset.Card (6.1s)
✔ [1369/1420] Built Mathlib.Algebra.GroupWithZero.Pi (2.5s)
✔ [1370/1420] Built Mathlib.Order.ModularLattice (6.2s)
✔ [1371/1421] Built Mathlib.Order.WellQuasiOrder (4.1s)
✔ [1372/1421] Built Mathlib.Algebra.Group.Action.Pi (3.9s)
✔ [1373/1421] Built Mathlib.Tactic.Ring.PNat (4.8s)
✔ [1374/1422] Built Mathlib.Data.Set.Card (9.2s)
✔ [1375/1422] Built Mathlib.Algebra.Order.SuccPred.WithBot (4.2s)
✔ [1376/1422] Built Mathlib.Order.SupClosed (7.3s)
✔ [1377/1425] Built Mathlib.Data.ENat.Lattice (5.8s)
✔ [1378/1425] Built Mathlib.Algebra.Ring.Pi (8.1s)
✔ [1379/1425] Built Mathlib.Algebra.GroupWithZero.Action.Pi (7.6s)
✔ [1380/1425] Built Mathlib.Data.DFinsupp.Defs (12s)
✔ [1381/1425] Built Mathlib.Algebra.Module.Equiv.Defs (19s)
✔ [1382/1425] Built Mathlib.Tactic.Ring (7.0s)
✔ [1383/1425] Built Mathlib.Order.WellFoundedSet (10s)
✔ [1384/1427] Built Mathlib.Order.SupIndep (11s)
✔ [1385/1433] Built Mathlib.SetTheory.Cardinal.NatCard (6.4s)
✔ [1386/1433] Built Mathlib.Basic.Rel (10s)
✔ [1387/1435] Built Mathlib.Data.Fintype.Pigeonhole (4.1s)
✔ [1388/1435] Built Mathlib.Algebra.Module.Pi (3.9s)
✔ [1389/1437] Built Mathlib.Order.Atoms (13s)
✔ [1390/1437] Built Mathlib.Algebra.Group.Hom.End (3.2s)
✔ [1391/1437] Built Mathlib.Algebra.Module.Equiv.Opposite (4.2s)
✔ [1392/1439] Built Mathlib.Data.Fin.VecNotation (7.1s)
✔ [1393/1439] Built Mathlib.Algebra.GroupWithZero.Action.Hom (3.4s)
✔ [1394/1439] Built Mathlib.Algebra.GroupWithZero.ULift (2.6s)
✔ [1395/1439] Built Mathlib.Algebra.Group.Submonoid.Pointwise (6.6s)
✔ [1396/1440] Built Mathlib.Algebra.Group.Subgroup.Finite (6.2s)
✔ [1397/1440] Built Mathlib.Algebra.Module.Torsion.Pi (4.1s)
✔ [1398/1440] Built Mathlib.Algebra.Module.Submodule.Lattice (8.2s)
✔ [1399/1440] Built Mathlib.Algebra.Module.End (4.4s)
✔ [1400/1441] Built Mathlib.Data.DFinsupp.Module (5.9s)
✔ [1401/1442] Built Mathlib.RingTheory.NonUnitalSubsemiring.Defs (5.6s)
✔ [1402/1442] Built Mathlib.Order.CompactlyGenerated.Basic (8.1s)
✔ [1403/1442] Built Mathlib.Algebra.Ring.Action.Subobjects (4.6s)
✔ [1404/1443] Built Mathlib.GroupTheory.GroupAction.DomAct.Basic (6.8s)
✔ [1405/1443] Built Mathlib.Algebra.GroupWithZero.Submonoid.Pointwise (5.6s)
✔ [1406/1443] Built Mathlib.Algebra.Module.ULift (6.3s)
✔ [1407/1443] Built Mathlib.Algebra.Module.LinearMap.End (10s)
✔ [1408/1443] Built Mathlib.Algebra.Module.Submodule.RestrictScalars (7.5s)
✔ [1409/1444] Built Mathlib.RingTheory.Ideal.Lattice (6.4s)
✔ [1410/1444] Built Mathlib.Algebra.Group.Subgroup.Pointwise (10s)
✔ [1411/1445] Built Mathlib.Algebra.Group.Subsemigroup.Membership (6.1s)
✔ [1412/1445] Built Mathlib.LinearAlgebra.Span.Defs (9.0s)
✔ [1413/1448] Built Mathlib.Order.RelSeries (14s)
✔ [1414/1448] Built Mathlib.RingTheory.NonUnitalSubring.Defs (7.0s)
✔ [1415/1450] Built Mathlib.Algebra.Module.Hom (6.2s)
✔ [1416/1450] Built Mathlib.Algebra.Ring.Subsemiring.Defs (7.0s)
✔ [1417/1450] Built Mathlib.Algebra.GroupWithZero.Center (3.1s)
✔ [1418/1454] Built Mathlib.Algebra.Ring.Center (3.3s)
✔ [1419/1454] Built Mathlib.Algebra.Group.Subsemigroup.Operations (9.2s)
✔ [1420/1454] Built Mathlib.Algebra.Module.LinearMap.Basic (5.7s)
✔ [1421/1456] Built Mathlib.RingTheory.Ideal.Prime (3.7s)
✔ [1422/1460] Built Mathlib.Algebra.Ring.Centralizer (2.8s)
✔ [1423/1460] Built Mathlib.Algebra.Ring.Submonoid.Basic (2.6s)
✔ [1424/1466] Built Mathlib.Algebra.Module.Submodule.LinearMap (5.7s)
✔ [1425/1470] Built Mathlib.Algebra.GroupWithZero.Subgroup (4.1s)
✔ [1426/1473] Built Mathlib.Algebra.Ring.Hom.InjSurj (2.6s)
✔ [1427/1474] Built Mathlib.Algebra.Group.Action.TransferInstance (3.9s)
✔ [1428/1474] Built Mathlib.Algebra.NoZeroSMulDivisors.Defs (3.7s)
✔ [1429/1474] Built Mathlib.Order.KrullDimension (7.0s)
✔ [1430/1474] Built Mathlib.Algebra.Ring.Subring.Defs (5.6s)
✔ [1431/1474] Built Mathlib.Algebra.Ring.Aut (3.5s)
✔ [1432/1477] Built Mathlib.Algebra.Group.Pointwise.Set.ListOfFn (3.5s)
✔ [1433/1477] Built Mathlib.GroupTheory.QuotientGroup.Basic (9.7s)
✔ [1434/1479] Built Mathlib.RingTheory.NonUnitalSubsemiring.Basic (6.7s)
✔ [1435/1479] Built Mathlib.Algebra.GroupWithZero.Action.TransferInstance (3.5s)
✔ [1436/1479] Built Mathlib.Algebra.Ring.Action.Group (3.6s)
✔ [1437/1479] Built Mathlib.Algebra.Group.Shrink (4.2s)
✔ [1438/1479] Built Mathlib.Algebra.Group.Pointwise.Set.BigOperators (4.2s)
✔ [1439/1482] Built Mathlib.Algebra.Group.IsApply (2.9s)
✔ [1440/1484] Built Mathlib.Data.Finset.NAry (5.3s)
✔ [1441/1484] Built Mathlib.Algebra.Module.Submodule.Map (8.6s)
✔ [1442/1484] Built Mathlib.Algebra.BigOperators.Group.Finset.Lemmas (3.8s)
✔ [1443/1484] Built Mathlib.Algebra.FiniteSupport.Defs (2.9s)
✔ [1444/1484] Built Mathlib.Algebra.GroupWithZero.Indicator (2.7s)
✔ [1445/1484] Built Mathlib.Algebra.Module.TransferInstance (3.6s)
✔ [1446/1484] Built Mathlib.Algebra.Group.Indicator (3.6s)
✔ [1447/1485] Built Mathlib.Algebra.Module.Basic (3.5s)
✔ [1448/1485] Built Mathlib.RingTheory.NonUnitalSubring.Basic (6.7s)
✔ [1449/1485] Built Mathlib.Algebra.Module.Equiv.Basic (15s)
✔ [1450/1489] Built Mathlib.Algebra.Notation.FiniteSupport (3.6s)
✔ [1451/1489] Built Mathlib.Algebra.Module.Shrink (3.9s)
✔ [1452/1492] Built Mathlib.Algebra.Ring.Subsemiring.Basic (8.8s)
✔ [1453/1493] Built Mathlib.Algebra.BigOperators.Pi (5.3s)
✔ [1454/1493] Built Mathlib.Algebra.Module.Submodule.Ker (5.0s)
✔ [1455/1493] Built Mathlib.GroupTheory.Index (10s)
✔ [1456/1493] Built Mathlib.Algebra.Module.Submodule.Pointwise (6.9s)
✔ [1457/1493] Built Mathlib.Algebra.Order.Group.Indicator (4.2s)
✔ [1458/1495] Built Mathlib.Algebra.BigOperators.Group.Finset.Pi (3.0s)
✔ [1459/1500] Built Mathlib.Data.Multiset.Antidiagonal (3.6s)
✔ [1460/1500] Built Mathlib.Data.Multiset.Sections (3.6s)
✔ [1461/1500] Built Mathlib.Algebra.Order.Hom.GroupNorm (3.3s)
✔ [1462/1500] Built Mathlib.Algebra.Group.Pointwise.Finset.Basic (11s)
✔ [1463/1501] Built Mathlib.Algebra.Module.Submodule.EqLocus (3.0s)
✔ [1464/1509] Built Mathlib.Algebra.Order.BigOperators.GroupWithZero.Finset (4.4s)
✔ [1465/1510] Built Mathlib.Algebra.Order.BigOperators.GroupWithZero.List (3.0s)
✔ [1466/1510] Built Mathlib.Algebra.Order.BigOperators.Ring.List (3.8s)
✔ [1467/1518] Built Mathlib.Algebra.FiniteSupport.Basic (5.6s)
✔ [1468/1519] Built Mathlib.Algebra.Order.Hom.RingNorm (4.1s)
✔ [1469/1520] Built Mathlib.Algebra.Group.Pi.Torsion (3.6s)
✔ [1470/1520] Built Mathlib.Algebra.Module.Submodule.Range (7.6s)
✔ [1471/1520] Built Mathlib.Algebra.BigOperators.Ring.Multiset (5.2s)
✔ [1472/1524] Built Mathlib.Data.List.Find (4.5s)
✔ [1473/1524] Built Mathlib.Algebra.Order.BigOperators.GroupWithZero.Multiset (5.6s)
✔ [1474/1524] Built Mathlib.Data.Rat.BigOperators (4.4s)
✔ [1475/1525] Built Mathlib.Algebra.BigOperators.Group.Finset.Preimage (5.0s)
✔ [1476/1525] Built Mathlib.Algebra.Ring.NonZeroDivisors (4.0s)
✔ [1477/1526] Built Mathlib.Algebra.Ring.Submonoid.Pointwise (4.8s)
✔ [1478/1528] Built Mathlib.Algebra.Order.AbsoluteValue.Basic (5.6s)
✔ [1479/1529] Built Mathlib.Algebra.Ring.Subring.Basic (14s)
✔ [1480/1529] Built Mathlib.Algebra.Module.Submodule.Equiv (6.4s)
✔ [1481/1529] Built Mathlib.Algebra.BigOperators.Ring.Finset (5.0s)
✔ [1482/1529] Built Mathlib.Data.Multiset.Find (3.8s)
✔ [1483/1529] Built Mathlib.Algebra.Order.BigOperators.Ring.Multiset (3.8s)
✔ [1484/1529] Built Mathlib.Algebra.Order.Kleene (5.6s)
✔ [1485/1530] Built Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise (4.8s)
✔ [1486/1532] Built Mathlib.Data.Fintype.Lattice (3.7s)
✔ [1487/1532] Built Mathlib.Algebra.Field.IsField (3.6s)
✔ [1488/1534] Built Mathlib.RingTheory.Coprime.Basic (5.9s)
✔ [1489/1537] Built Mathlib.Data.Finset.Fin (4.3s)
✔ [1490/1537] Built Mathlib.Data.Finsupp.Defs (5.8s)
✔ [1491/1540] Built Mathlib.Data.Set.Semiring (6.1s)
✔ [1492/1542] Built Mathlib.Order.Interval.Set.Fin (7.9s)
✔ [1493/1542] Built Mathlib.Algebra.Algebra.Basic (10s)
✔ [1494/1542] Built Mathlib.Algebra.Order.BigOperators.Ring.Finset (9.5s)
✔ [1495/1542] Built Mathlib.RingTheory.Coprime.Lemmas (7.4s)
✔ [1496/1545] Built Mathlib.LinearAlgebra.Span.Basic (11s)
✔ [1497/1546] Built Mathlib.Data.Fintype.Order (6.1s)
✔ [1498/1546] Built Mathlib.Order.SuccPred.LinearLocallyFinite (6.4s)
✔ [1499/1546] Built Mathlib.Data.Finsupp.Single (5.4s)
✔ [1500/1546] Built Mathlib.Algebra.Order.Interval.Set.Monoid (3.0s)
✔ [1501/1546] Built Mathlib.Algebra.BigOperators.NatAntidiagonal (3.8s)
✔ [1502/1547] Built Mathlib.GroupTheory.OrderOfElement (30s)
✔ [1503/1548] Built Mathlib.Order.Interval.Finset.Fin (6.2s)
✔ [1504/1548] Built Mathlib.RingTheory.Ideal.Span (5.3s)
✔ [1505/1550] Built Mathlib.Order.PartialSups (5.1s)
✔ [1506/1550] Built Mathlib.Algebra.Algebra.Hom (8.1s)
✔ [1507/1555] Built Mathlib.Data.Finsupp.Indicator (5.3s)
✔ [1508/1555] Built Mathlib.Algebra.Group.Finsupp (6.8s)
✔ [1509/1555] Built Mathlib.Algebra.Order.Interval.Finset.Basic (4.6s)
✔ [1510/1555] Built Mathlib.RingTheory.Multiplicity (7.0s)
✔ [1511/1555] Built Mathlib.LinearAlgebra.BilinearMap (21s)
✔ [1512/1555] Built Mathlib.Tactic.Order.CollectFacts (4.0s)
✔ [1513/1555] Built Mathlib.RingTheory.Ideal.Maximal (5.2s)
✔ [1514/1555] Built Mathlib.Order.Disjointed (4.4s)
✔ [1515/1555] Built Mathlib.Data.Finsupp.SMulWithZero (4.1s)
✔ [1516/1555] Built Mathlib.Data.Finsupp.Ext (4.3s)
✔ [1517/1558] Built Mathlib.Data.ZMod.Basic (9.3s)
✔ [1518/1558] Built Mathlib.Algebra.BigOperators.Finprod (14s)
✔ [1519/1560] Built Mathlib.Tactic.Order.ToInt (4.2s)
✔ [1520/1560] Built Mathlib.Tactic.Order.Preprocessing (3.8s)
✔ [1521/1560] Built Mathlib.Algebra.Module.Submodule.Bilinear (5.3s)
✔ [1522/1563] Built Mathlib.Tactic.Order.Graph.Basic (3.5s)
✔ [1523/1565] Built Mathlib.RingTheory.Ideal.Nonunits (4.0s)
✔ [1524/1565] Built Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite (5.1s)
✔ [1525/1565] Built Mathlib.Algebra.Algebra.ZMod (4.2s)
✔ [1526/1566] Built Mathlib.Algebra.Algebra.NonUnitalHom (10s)
✔ [1527/1567] Built Mathlib.Algebra.BigOperators.GroupWithZero.Action (4.3s)
✔ [1528/1571] Built Mathlib.Order.Filter.Defs (4.0s)
✔ [1529/1571] Built Mathlib.Order.Interval.Set.Disjoint (4.4s)
✔ [1530/1571] Built Mathlib.Algebra.Algebra.Equiv (12s)
✔ [1531/1572] Built Mathlib.Tactic.Order.Graph.Tarjan (2.9s)
✔ [1532/1572] Built Mathlib.Algebra.Order.Group.Action.Synonym (2.9s)
✔ [1533/1572] Built Mathlib.Algebra.BigOperators.Finsupp.Basic (8.6s)
✔ [1534/1573] Built Mathlib.Algebra.Order.Group.Basic (3.7s)
✔ [1535/1575] Built Mathlib.Algebra.Order.GroupWithZero.Synonym (2.7s)
✔ [1536/1575] Built Mathlib.Algebra.Module.BigOperators (5.2s)
✔ [1537/1577] Built Mathlib.LinearAlgebra.TensorProduct.Defs (10s)
✔ [1538/1577] Built Mathlib.Algebra.BigOperators.Intervals (8.1s)
✔ [1539/1578] Built Mathlib.Algebra.Group.Fin.Tuple (4.6s)
✔ [1540/1578] Built Mathlib.Order.Filter.Basic (7.6s)
✔ [1541/1578] Built Aeneas.Tactic.Simproc.ReduceZMod.ReduceZMod (9.2s)
✔ [1542/1579] Built Mathlib.Tactic.Order (5.3s)
✔ [1543/1579] Built Mathlib.Algebra.Algebra.Prod (5.1s)
✔ [1544/1579] Built Mathlib.Algebra.Order.GroupWithZero.Action.Synonym (3.9s)
✔ [1545/1579] Built Mathlib.Algebra.Algebra.Opposite (7.9s)
✔ [1546/1579] Built Mathlib.Logic.Equiv.Fin.Basic (4.9s)
✔ [1547/1581] Built Mathlib.Order.Filter.AtTopBot.Defs (4.0s)
✔ [1548/1581] Built Mathlib.Algebra.Group.Graph (6.9s)
✔ [1549/1586] Built Mathlib.Data.Nat.Choose.Sum (6.1s)
✔ [1550/1586] Built Mathlib.Data.Set.Finite.Lemmas (5.1s)
✔ [1551/1586] Built Mathlib.Order.Filter.Map (5.0s)
✔ [1552/1586] Built Mathlib.LinearAlgebra.Quotient.Defs (6.5s)
✔ [1553/1586] Built Mathlib.Order.Filter.AtTopBot.Disjoint (3.5s)
✔ [1554/1597] Built Mathlib.Order.Filter.Tendsto (3.9s)
✔ [1555/1597] Built Mathlib.Data.Finsupp.Basic (15s)
✔ [1556/1598] Built Mathlib.Order.Filter.Bases.Basic (5.5s)
✔ [1557/1598] Built Mathlib.LinearAlgebra.TensorProduct.Basic (13s)
✔ [1558/1598] Built Mathlib.Algebra.GroupWithZero.Submonoid.Primal (4.6s)
✔ [1559/1598] Built Aeneas.Tactic.Solver.ScalarTac.Lemmas (12s)
✔ [1560/1598] Built Mathlib.Algebra.Algebra.Tower (8.4s)
✔ [1561/1601] Built Mathlib.Order.Filter.AtTopBot.Tendsto (4.1s)
✔ [1562/1601] Built Mathlib.Data.BitVec (4.5s)
✔ [1563/1603] Built Mathlib.Algebra.Order.Module.Defs (12s)
✔ [1564/1603] Built Mathlib.GroupTheory.FreeGroup.Basic (11s)
✔ [1565/1611] Built Mathlib.Data.Finsupp.SMul (4.0s)
✔ [1566/1611] Built Mathlib.Data.Finsupp.Option (5.2s)
✔ [1567/1614] Built Aeneas.Std.Scalar.BvComp (6.7s)
✔ [1568/1614] Built Mathlib.RingTheory.UniqueFactorizationDomain.Defs (4.2s)
✔ [1569/1618] Built Mathlib.Order.Filter.AtTopBot.Basic (4.6s)
✔ [1570/1623] Built Mathlib.LinearAlgebra.Prod (14s)
✔ [1571/1623] Built Mathlib.Tactic.Algebraize (5.5s)
✔ [1572/1625] Built Mathlib.Data.List.GetD (2.2s)
✔ [1573/1625] Built Batteries.Data.Nat.Bitwise.Lemmas (1.2s)
✔ [1574/1627] Built Mathlib.Algebra.Order.Nonneg.Module (4.4s)
✔ [1575/1629] Built Aeneas.Tactic.Simp.SimpLemmas (2.6s)
✔ [1576/1630] Built Batteries.Data.Nat.Bitwise (865ms)
✔ [1577/1630] Built Batteries.Data.BitVec.Basic (881ms)
✔ [1578/1630] Built Batteries.Data.Fin.OfBits (839ms)
✔ [1579/1632] Built Aeneas.Data.ListN (1.6s)
✔ [1580/1634] Built Batteries.Data.Int (861ms)
✔ [1581/1634] Built Aeneas.Std.Scalar.CloneCopy (6.1s)
✔ [1582/1636] Built Aeneas.Std.Core.Default (3.6s)
✔ [1583/1646] Built Aeneas.Tactic.Conv.Natify.Init (2.2s)
✔ [1584/1647] Built Batteries.Data.BitVec.Lemmas (1.1s)
✔ [1585/1648] Built Aeneas.Tactic.Conv.ZModify.Init (2.5s)
✔ [1586/1650] Built Mathlib.LinearAlgebra.Finsupp.Defs (7.6s)
✔ [1587/1657] Built Aeneas.Data.Byte (3.3s)
✔ [1588/1658] Built Mathlib.GroupTheory.Finiteness (8.5s)
✔ [1589/1658] Built Mathlib.Data.Nat.Bitwise (4.9s)
✔ [1590/1658] Built Aeneas.Tactic.Simproc.ReduceNat (3.8s)
✔ [1591/1658] Built Mathlib.LinearAlgebra.TensorProduct.Map (15s)
✔ [1592/1658] Built Mathlib.LinearAlgebra.Pi (9.3s)
✔ [1593/1660] Built Aeneas.Std.Scalar.LeadingZeros (5.8s)
✔ [1594/1660] Built Aeneas.Std.SliceDef (6.4s)
✔ [1595/1661] Built Mathlib.RingTheory.Finiteness.Defs (4.3s)
✔ [1596/1661] Built Aeneas.Std.Scalar.Pow (5.7s)
✔ [1597/1661] Built Mathlib.LinearAlgebra.Finsupp.LSum (6.5s)
✔ [1598/1662] Built Aeneas.Std.Scalar.Rotate (5.0s)
✔ [1599/1662] Built Aeneas.Std.Scalar.EqOrd (7.4s)
✔ [1600/1665] Built Aeneas.Std.Scalar.SaturatingOps (4.0s)
✔ [1601/1665] Built Aeneas.Tactic.Simp.SimpScalar.SimpScalar (5.6s)
✔ [1602/1665] Built Aeneas.Tactic.Simp.SimpLists.SimpLists (5.0s)
✔ [1603/1666] Built Mathlib.LinearAlgebra.Finsupp.Supported (4.2s)
✔ [1604/1670] Built Aeneas.Std.StringDef (5.4s)
✔ [1605/1671] Built Mathlib.Algebra.Algebra.Bilinear (5.0s)
✔ [1606/1671] Built Aeneas.Std.Scalar.WrappingOps.Mul (5.8s)
✔ [1607/1678] Built Aeneas.Std.Scalar.WrappingOps.Add (6.2s)
✔ [1608/1678] Built Aeneas.Std.Scalar.WrappingOps.Shl (5.9s)
✔ [1609/1679] Built Mathlib.RingTheory.Finiteness.Basic (6.3s)
✔ [1610/1684] Built Aeneas.Std.Scalar.WrappingOps.Shr (5.6s)
✔ [1611/1687] Built Aeneas.Std.Scalar.WrappingOps.Sub (6.0s)
✔ [1612/1687] Built Mathlib.Control.Lawful (1.0s)
✔ [1613/1690] Built Mathlib.Control.Monad.Writer (2.8s)
✔ [1614/1693] Built Aeneas.Std.Alloc.String (3.4s)
✔ [1615/1695] Built Aeneas.Tactic.Simp.SimpScalar.Lemmas (6.6s)
✔ [1616/1695] Built Mathlib.Algebra.Module.Submodule.Finsupp (4.3s)
✔ [1617/1696] Built Aeneas.Std.Core.Atomic (3.5s)
✔ [1618/1697] Built Mathlib.RingTheory.Noetherian.Defs (4.3s)
✔ [1619/1697] Built Aeneas.Std.RawPtr (5.7s)
✔ [1620/1697] Built Mathlib.Control.Monad.Cont (2.7s)
✔ [1621/1699] Built Mathlib.LinearAlgebra.Finsupp.LinearCombination (7.2s)
✔ [1622/1700] Built Aeneas.Std.Core.Panic (3.1s)
✔ [1623/1704] Built Aeneas.Std.Core.CoreResult (4.2s)
✔ [1624/1714] Built Aeneas.Std.Core.Marker (3.9s)
✔ [1625/1715] Built Aeneas.Std.Scalar.WrappingOps (5.1s)
✔ [1626/1717] Built Aeneas.Std.Core.Pin (3.2s)
✔ [1627/1717] Built Aeneas.Tactic.Simp.SimpScalar.Tests (5.8s)
✔ [1628/1721] Built Aeneas.Std.PrimitivesLemmas (4.5s)
✔ [1629/1721] Built Aeneas.Tactic.Simp.SimpIfs.Init (2.8s)
✔ [1630/1721] Built Aeneas.Data.Tuples (3.9s)
✔ [1631/1722] Built Aeneas.Std.Core.Ptr (5.6s)
✔ [1632/1723] Built Mathlib.RingTheory.Ideal.Basic (5.2s)
✔ [1633/1725] Built Aeneas.Data.Range.DivRange.Basic (4.2s)
✔ [1634/1726] Built Aeneas.Data.Fin (7.5s)
✔ [1635/1744] Built Aeneas.Data.Range.Lemmas (5.3s)
✔ [1636/1745] Built Aeneas.Do.Elab (9.9s)
✔ [1637/1747] Built Aeneas.Data.Range.Notations (7.1s)
✔ [1638/1747] Built Aeneas.Tactic.Elab.TraitDefault.Test (1.5s)
✔ [1639/1747] Built Aeneas.Data.Range.MulRange.Basic (5.3s)
✔ [1640/1747] Built Aeneas.Tactic.Simp.SimpScalar (7.8s)
✔ [1641/1751] Built Aeneas.Tactic.Simp.SimpIfs.SimpIfs (7.2s)
✔ [1642/1752] Built Aeneas.Data.Range.DivRange.Lemmas (6.1s)
✔ [1643/1752] Built Aeneas.Tactic.Misc.FCongr.FCongr (1.4s)
✔ [1644/1753] Built Aeneas.Std.Core.Alloc (7.3s)
✔ [1645/1753] Built Mathlib.Algebra.Algebra.Operations (13s)
✔ [1646/1753] Built Aeneas.Data.Range.SRRange.Basic (3.7s)
✔ [1647/1753] Built Aeneas.Tactic.Elab.TraitDefault (1.7s)
✔ [1648/1753] Built Aeneas.Tactic.Misc.FApplyExact (2.8s)
✔ [1649/1755] Built Aeneas.Tactic.Misc.FCongr (1.3s)
✔ [1650/1760] Built Aeneas.Tactic.Elab (1.3s)
✔ [1651/1760] Built Aeneas.Tactic.RustAttributes (2.6s)
✔ [1652/1763] Built Aeneas.Tactic.Misc.Let.Let (3.5s)
✔ [1653/1768] Built Aeneas.Data.Range.DivRange.Notations (6.6s)
✔ [1654/1768] Built Aeneas.Data.Range.MulRange.Notations (6.3s)
✔ [1655/1768] Built Aeneas.Tactic.Solver.BvTac.Init (3.0s)
✔ [1656/1774] Built Aeneas.Tactic.Simp.SimpIfs (6.2s)
✔ [1657/1775] Built Aeneas.Tactic.Misc.Let (3.1s)
✔ [1658/1775] Built Aeneas.Data.Range.MulRange.Lemmas (6.2s)
✔ [1659/1778] Built Aeneas.Tactic.Simp.SimpBoolProp (6.0s)
✔ [1660/1782] Built Aeneas.Data.Range.SRRange.Notations (5.9s)
✔ [1661/1783] Built Aeneas.Tactic.Simp.RingEqNF.Tactic (5.4s)
✔ [1662/1784] Built Aeneas.Tactic.Solver.Grind (1.8s)
✔ [1663/1785] Built Aeneas.Tactic.Simproc.ReduceFin.Init (2.7s)
✔ [1664/1785] Built Aeneas.Tactic.Misc (3.2s)
✔ [1665/1814] Built Aeneas.Data.Range.DivRange (5.0s)
✔ [1667/1893] Built Aeneas.Tactic.Simproc.ReduceZMod (5.9s)
✔ [1668/1893] Built Aeneas.Tactic.Step.InferPost (5.5s)
✔ [1669/1893] Built Aeneas.Data.Range.MulRange (5.3s)
✔ [1670/1893] Built Aeneas.Tactic.Simproc.ReduceFin.ReduceFin (3.4s)
✔ [1671/1893] Built Aeneas.Tactic.Simp.RingEqNF.Tests (5.7s)
✔ [1672/1893] Built AeneasMeta.Split (6.8s)
✔ [1673/1893] Built Aeneas.Tactic.Solver.Grind.Tests (5.5s)
✔ [1674/1893] Built Mathlib.RingTheory.Ideal.Operations (12s)
✔ [1675/1893] Built Aeneas.Tactic.Simproc.ReduceFin (2.7s)
✔ [1676/1893] Built Aeneas.Tactic.Simp.RingEqNF (3.2s)
✔ [1677/1893] Built Mathlib.RingTheory.UniqueFactorizationDomain.Ideal (2.9s)
✔ [1678/1893] Built Mathlib.RingTheory.Noetherian.UniqueFactorizationDomain (2.8s)
✔ [1679/1893] Built Aeneas.Tactic.Solver.ScalarTac.Tests (12s)
✔ [1680/1893] Built Mathlib.RingTheory.Ideal.Maps (6.0s)
✔ [1681/1893] Built Mathlib.RingTheory.Ideal.Prod (1.8s)
✔ [1682/1893] Built Mathlib.RingTheory.PrincipalIdealDomain (1.0s)
✔ [1683/1893] Built Mathlib.RingTheory.Int.Basic (1.6s)
✔ [1684/1893] Built Aeneas.Tactic.Solver.Arith.Lemmas (2.9s)
✔ [1685/1893] Built Aeneas.Tactic.Solver.Arith (3.6s)
✔ [1686/1893] Built Aeneas.Tactic.Solver.ScalarTac (4.1s)
✔ [1687/1893] Built Aeneas.Tactic.Conv.Zify (4.3s)
✔ [1688/1893] Built Aeneas.Tactic.Conv.Natify.Natify (4.6s)
✔ [1689/1893] Built Aeneas.Tactic.Conv.ZModify.ZModify (4.6s)
✔ [1690/1893] Built Aeneas.Std.Range (5.1s)
✔ [1691/1893] Built Aeneas.Std.Scalar.Misc (6.5s)
✔ [1692/1893] Built Aeneas.Tactic.Solver.ScalarDecrTac (6.5s)
✔ [1693/1893] Built Aeneas.Std.Scalar.Bitwise (7.3s)
✔ [1694/1893] Built Aeneas.Tactic.Conv.Natify (6.7s)
✔ [1695/1893] Built Aeneas.Tactic.Conv.ZModify (6.7s)
✔ [1696/1893] Built Aeneas.Tactic.Step.GrindState (7.3s)
✔ [1697/1893] Built Aeneas.Std.Scalar.Casts (7.6s)
✔ [1698/1893] Built Aeneas.Data.List.List (10s)
✔ [1699/1893] Built Aeneas.Std.Scalar.Ops.Neg (5.2s)
✔ [1700/1893] Built Aeneas.Std.Scalar.Ops.Rem (5.9s)
✔ [1701/1893] Built Aeneas.Std.Scalar.Ops.Sub (6.3s)
✔ [1702/1893] Built Aeneas.Std.Scalar.Ops.Mul (6.5s)
✔ [1703/1893] Built Aeneas.Std.Scalar.Ops.Add (6.1s)
✔ [1704/1893] Built Aeneas.Std.Scalar.Ops.Div (7.5s)
✔ [1705/1893] Built Aeneas.Data.List (6.2s)
✔ [1706/1893] Built Aeneas.Std.Array.Core (6.4s)
✔ [1707/1893] Built Aeneas.Data.Range.SRRange.Lemmas (7.0s)
✔ [1708/1893] Built Aeneas.Std.Scalar.CheckedOps.Rem (5.9s)
✔ [1709/1893] Built Aeneas.Std.Scalar.CheckedOps.Mul (6.5s)
✔ [1710/1893] Built Aeneas.Std.Scalar.CheckedOps.Sub (6.8s)
✔ [1711/1893] Built Aeneas.Std.Scalar.CheckedOps.Add (6.8s)
✔ [1712/1893] Built Aeneas.Std.Scalar.Ops (5.9s)
✔ [1713/1893] Built Aeneas.Std.Scalar.Notations (7.5s)
✔ [1714/1893] Built Aeneas.Std.Scalar.CheckedOps.Div (6.6s)
✔ [1715/1893] Built Aeneas.Data.Array (6.4s)
✔ [1716/1893] Built Aeneas.Std.Array.Array (8.2s)
✔ [1717/1893] Built Aeneas.Data.Range.SRRange (6.4s)
✔ [1718/1893] Built Aeneas.Data.BitVec (10s)
✔ [1719/1893] Built Aeneas.Std.Scalar.OverflowingOps.Div (7.8s)
✔ [1720/1893] Built Aeneas.Data.Discriminant (8.2s)
✔ [1721/1893] Built Aeneas.Std.Scalar.OverflowingOps.Mul (8.4s)
✔ [1722/1893] Built Aeneas.Std.Scalar.Default (6.6s)
✔ [1723/1893] Built Aeneas.Std.Slice (11s)
✔ [1724/1893] Built Aeneas.Std.Scalar.OverflowingOps.Sub (9.5s)
✔ [1725/1893] Built Aeneas.Std.Scalar.CheckedOps (5.6s)
✔ [1726/1893] Built Aeneas.Data.Vector (6.3s)
✔ [1727/1893] Built Aeneas.Std.Core.Fmt (5.5s)
✔ [1728/1893] Built Aeneas.Data.Range (4.7s)
✔ [1729/1893] Built Aeneas.Std.Scalar.OverflowingOps.Add (12s)
✔ [1730/1893] Built Aeneas.Std.Core.Hash (5.2s)
✔ [1731/1893] Built Aeneas.Std.Scalar.CoreConvertNum (7.3s)
✔ [1732/1893] Built Aeneas.Tactic.Setup (6.1s)
✔ [1733/1893] Built Aeneas.Std.Core.Error (6.1s)
✔ [1734/1893] Built Aeneas.Std.Std.Io (6.1s)
✔ [1735/1893] Built Aeneas.Std.Array.ArrayDebug (6.6s)
✔ [1736/1893] Built Aeneas.Std.Scalar.Fmt (6.1s)
✔ [1737/1893] Built Aeneas.Std.Core.Iter (7.9s)
✔ [1738/1893] Built Aeneas.Std.Scalar.Display (6.0s)
✔ [1739/1893] Built Aeneas.Std.Array.ArraySlice (7.8s)
✔ [1740/1893] Built Aeneas.Data (5.6s)
✔ [1741/1893] Built Aeneas.Std.Scalar.OverflowingOps (5.4s)
✔ [1742/1893] Built Aeneas.Std.Core.Discriminant (4.9s)
✔ [1743/1893] Built Aeneas.Std.Std (4.6s)
✔ [1744/1893] Built Aeneas.Std.Array (4.0s)
✔ [1745/1893] Built Aeneas.Std.SliceIter (5.8s)
✔ [1746/1893] Built Aeneas.Std.Scalar (3.5s)
✔ [1747/1893] Built Aeneas.Std.Target (4.2s)
✔ [1748/1893] Built Aeneas.Std.String (4.3s)
✔ [1749/1893] Built Aeneas.Std.Alloc.Vec (6.4s)
✔ [1750/1893] Built Aeneas.Std.RangeIter (7.1s)
✔ [1751/1893] Built Aeneas.Std.Core.FmtWithSlice (4.0s)
✔ [1752/1893] Built Aeneas.Std.Core.CoreOption (5.2s)
✔ [1753/1893] Built Aeneas.Std.StringIter (5.6s)
✔ [1754/1893] Built Aeneas.Std.Alloc.Slice (4.6s)
✔ [1755/1893] Built Aeneas.Std.Alloc.Vec.IntoIter (4.6s)
✔ [1756/1893] Built Aeneas.Std.Core (3.8s)
✔ [1757/1893] Built Aeneas.Tactic.Conv.Bvify.Bvify (13s)
✔ [1758/1893] Built Aeneas.Std.Alloc (3.3s)
✔ [1759/1893] Built Aeneas.Std (2.7s)
✔ [1760/1893] Built Aeneas.Tactic.Conv.Bvify.Lemmas (3.8s)
✔ [1761/1893] Built Aeneas.Tactic.Conv.Bvify.Tests (3.0s)
✔ [1762/1893] Built Aeneas.Tactic.Conv.Bvify (3.6s)
✔ [1763/1893] Built Aeneas.Do.Delab (4.9s)
✔ [1764/1893] Built Aeneas.Tactic.Simp.SimpLists.Tests (6.6s)
✔ [1765/1893] Built Aeneas.Tactic.Conv (4.2s)
✔ [1766/1893] Built Aeneas.Command.Decompose.TestsRec (4.7s)
✔ [1767/1893] Built Aeneas.Tactic.Simp.SimpLists (3.3s)
✔ [1768/1893] Built Aeneas.Do.Tests (5.2s)
✔ [1769/1893] Built Aeneas.Command.Decompose.Tests (7.0s)
✔ [1770/1893] Built Aeneas.Tactic.Simp.SimpListsScalar (3.3s)
✔ [1771/1893] Built Aeneas.Do (3.8s)
✔ [1772/1893] Built Aeneas.Tactic.Simp (2.6s)
✔ [1773/1893] Built Aeneas.Command.Decompose.TestsBig (16s)
✔ [1774/1893] Built Aeneas.Command (1.9s)
✔ [1775/1893] Built Aeneas.Tactic.Step.Step (9.7s)
✔ [1776/1893] Built Aeneas.Tactic.Solver.BvTac.BvTac (20s)
✔ [1777/1893] Built Aeneas.Tactic.Step.Tests.DspecInduction (3.0s)
✔ [1778/1893] Built Aeneas.Tactic.Step.StepArraySpec (4.8s)
✔ [1779/1893] Built Aeneas.Tactic.Simproc.BvSimprocs (4.7s)
✔ [1780/1893] Built Aeneas.Tactic.Simproc (3.3s)
✔ [1781/1893] Built Aeneas.Tactic.Step.StepStar (9.7s)
✔ [1782/1893] Built Aeneas.Tactic.Solver.BvTac.Lemmas (10s)
✔ [1783/1893] Built Aeneas.Tactic.Step.Deprecated (2.8s)
✔ [1784/1893] Built Aeneas.Tactic.Solver.BvTac (2.5s)
✔ [1785/1893] Built Aeneas.Tactic.Solver.BvTac.Tests (12s)
✔ [1786/1893] Built Aeneas.Tactic.Step (2.6s)
✔ [1787/1893] Built Aeneas.Tactic.Solver (4.3s)
✔ [1788/1893] Built Aeneas.Tactic.Step.Tests.SpecParameters (6.2s)
✔ [1789/1893] Built Aeneas.Tactic.Step.Tests.TupleDestruct (6.4s)
✔ [1790/1893] Built Aeneas.Tactic.Step.Tests.MaxRecDepthMetavar (6.7s)
✔ [1791/1893] Built Aeneas.Tactic.Step.Tests.HigherOrderOption (6.0s)
✔ [1792/1893] Built Aeneas.Tactic.Step.Tests.MvcgenSpec (6.9s)
✔ [1793/1893] Built Aeneas.Tactic.Step.Tests.UncurryBind (6.9s)
✔ [1794/1893] Built Aeneas.Tactic.Step.Tests.Coin (7.9s)
✔ [1795/1893] Built Aeneas.Tactic.Step.Tests.ParserErrors (5.3s)
✔ [1796/1893] Built Aeneas.Tactic.Step.Tests.HigherOrder (9.4s)
✔ [1797/1893] Built Aeneas.Tactic.Step.Tests.IntroOutputs (9.9s)
✔ [1798/1893] Built Aeneas.Tactic.Step.Tests.DischargeTactic (4.3s)
✔ [1799/1893] Built Aeneas.Tactic.Step.Tests.IntroOutputsRecursion (4.7s)
✔ [1800/1893] Built Aeneas.Tactic.Step.Tests.Triple (4.5s)
✔ [1801/1893] Built Aeneas.Tactic.Step.Tests (2.2s)
✔ [1802/1893] Built Aeneas.Tactic.Tests (313ms)
✔ [1803/1893] Built Aeneas.Tactic (2.2s)
✔ [1804/1893] Built Aeneas (2.1s)
✔ [1805/1893] Built CrcStage2.Types (2.4s)
✔ [1806/1893] Built CrcBody.Types (2.4s)
✔ [1807/1893] Built Crc (2.6s)
✔ [1808/1893] Built CrcStage2.FunsExternal (2.2s)
✔ [1809/1893] Built CrcStage2.Funs (2.4s)
✔ [1810/1893] Built CrcBody.FunsExternal (2.1s)
✔ [1811/1893] Built CrcBody.Funs (4.9s)
✔ [1812/1893] Built CrcProofs.Util (14s)
⚠ [1813/1893] Built Stage2Proofs.InitFinalize (4.1s)
warning: Stage2Proofs/InitFinalize.lean:85:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:92:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:104:15: This simp argument is unused:
hri
Hint: Omit it from the simp argument list.
[apply] simp only [hro, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u8, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:104:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u8, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:122:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:129:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:141:15: This simp argument is unused:
hri
Hint: Omit it from the simp argument list.
[apply] simp only [hro, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u16, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:141:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u16, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:160:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:167:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:179:15: This simp argument is unused:
hri
Hint: Omit it from the simp argument list.
[apply] simp only [hro, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u32, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:179:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u32, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:198:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:205:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:217:15: This simp argument is unused:
hri
Hint: Omit it from the simp argument list.
[apply] simp only [hro, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u64, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:217:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u64, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:236:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:243:24: This simp argument is unused:
UScalarTy.numBits
Hint: Omit it from the simp argument list.
[apply] simp only [rawInit]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:255:15: This simp argument is unused:
hri
Hint: Omit it from the simp argument list.
[apply] simp only [hro, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u128, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/InitFinalize.lean:255:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.false_xor, Bool.true_xor, Bool.not_false, Bool.not_true, Bool.false_eq_true, ↓reduceIte,
reverse_bits_u128, bind_ok, rawFinalize]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1814/1893] Built CrcProofs.Wide (6.0s)
✔ [1815/1893] Built CrcProofs.EightPolynomial (46s)
✔ [1816/1893] Built Stage2Proofs.WordProtocols (49s)
✔ [1817/1893] Built Stage2Proofs.Public128Base (49s)
⚠ [1818/1893] Built Stage2Proofs.Reflected128Base (49s)
warning: Stage2Proofs/Reflected128Base.lean:41:24: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hw, hri, Bool.true_xor, Bool.not_false, ↓reduceIte, reverse128, bind_ok, Bool.false_eq_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/Reflected128Base.lean:57:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.true_xor, Bool.not_true, Bool.false_eq_true, ↓reduceIte, bind_ok]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1819/1893] Built Stage2Proofs.Public16Base (49s)
⚠ [1820/1893] Built Stage2Proofs.Reflected32Base (49s)
warning: Stage2Proofs/Reflected32Base.lean:41:24: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hw, hri, Bool.true_xor, Bool.not_false, ↓reduceIte, reverse32, bind_ok, Bool.false_eq_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/Reflected32Base.lean:57:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.true_xor, Bool.not_true, Bool.false_eq_true, ↓reduceIte, bind_ok]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1821/1893] Built Stage2Proofs.Public64Base (49s)
⚠ [1822/1893] Built Stage2Proofs.Reflected64Base (49s)
warning: Stage2Proofs/Reflected64Base.lean:41:24: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hw, hri, Bool.true_xor, Bool.not_false, ↓reduceIte, reverse64, bind_ok, Bool.false_eq_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/Reflected64Base.lean:57:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.true_xor, Bool.not_true, Bool.false_eq_true, ↓reduceIte, bind_ok]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
⚠ [1823/1893] Built Stage2Proofs.Reflected16Base (49s)
warning: Stage2Proofs/Reflected16Base.lean:41:24: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hw, hri, Bool.true_xor, Bool.not_false, ↓reduceIte, reverse16, bind_ok, Bool.false_eq_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/Reflected16Base.lean:57:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.true_xor, Bool.not_true, Bool.false_eq_true, ↓reduceIte, bind_ok]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1824/1893] Built Stage2Proofs.Public32Base (49s)
✔ [1825/1893] Built Stage2Proofs.ByteMath (10s)
✔ [1826/1893] Built Stage2Proofs.WordProtocolInstances (10s)
✔ [1827/1893] Built Stage2Proofs.Public8Base (24s)
✔ [1828/1893] Built Stage2Proofs.Update8 (24s)
✔ [1829/1893] Built Stage2Proofs.Update128Reflected (25s)
✔ [1830/1893] Built Stage2Proofs.Update16Reflected (25s)
✔ [1831/1893] Built Stage2Proofs.Update32Reflected (25s)
⚠ [1832/1893] Built Stage2Proofs.Update64Reflected (25s)
warning: Stage2Proofs/Update64Reflected.lean:19:48: Unused tactic linter: `<;>` should be replaced with `;` or be removed.
Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: Stage2Proofs/Update64Reflected.lean:19:48: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice
Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
✔ [1833/1893] Built Stage2Proofs.Update128 (25s)
⚠ [1834/1893] Built Stage2Proofs.Update64 (25s)
warning: Stage2Proofs/Update64.lean:19:48: Unused tactic linter: `<;>` should be replaced with `;` or be removed.
Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: Stage2Proofs/Update64.lean:19:48: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice
Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
✔ [1835/1893] Built Stage2Proofs.Update32 (25s)
✔ [1836/1893] Built Stage2Proofs.Update16 (26s)
✔ [1837/1893] Built Stage2Proofs.Public8 (9.6s)
✔ [1838/1893] Built Stage2Proofs.ReflectMath8 (10s)
✔ [1839/1893] Built Stage2Proofs.ByteMathWide (10s)
✔ [1840/1893] Built Stage2Proofs.Refout8 (7.8s)
⚠ [1841/1893] Built Stage2Proofs.Reflected8 (7.7s)
warning: Stage2Proofs/Reflected8.lean:42:24: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hw, hri, Bool.true_xor, Bool.not_false, ↓reduceIte, reverse8, bind_ok, Bool.false_eq_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/Reflected8.lean:58:20: This simp argument is unused:
hro
Hint: Omit it from the simp argument list.
[apply] simp only [hri, Bool.true_xor, Bool.not_true, Bool.false_eq_true, ↓reduceIte, bind_ok]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1842/1893] Built Stage2Proofs.NoTable8 (7.9s)
⚠ [1843/1893] Built Stage2Proofs.ReflectMathWide (9.9s)
warning: Stage2Proofs/ReflectMathWide.lean:139:34: Variable name `hN` is not explicitly referenced.
Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
[apply] _hN
Note: This linter can be disabled with `set_option linter.unusedVariables false`
warning: Stage2Proofs/ReflectMathWide.lean:151:24: This simp argument is unused:
hi
Hint: Omit it from the simp argument list.
[apply] simp only [hi8, hsub, decide_false, decide_true, Bool.not_false, Bool.true_and, Bool.and_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:151:42: This simp argument is unused:
decide_true
Hint: Omit it from the simp argument list.
[apply] simp only [hi8, hsub, hi, decide_false, Bool.not_false, Bool.true_and, Bool.and_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:151:71: This simp argument is unused:
Bool.true_and
Hint: Omit it from the simp argument list.
[apply] simp only [hi8, hsub, hi, decide_false, decide_true, Bool.not_false, Bool.and_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:167:40: This simp argument is unused:
decide_false
Hint: Omit it from the simp argument list.
[apply] simp only [hi, hb, hm, decide_true, Bool.true_and, Bool.false_and, Bool.and_true, Bool.and_false]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:167:69: This simp argument is unused:
Bool.false_and
Hint: Omit it from the simp argument list.
[apply] simp only [hi, hb, hm, decide_true, decide_false, Bool.true_and, Bool.and_true, Bool.and_false]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:167:100: This simp argument is unused:
Bool.and_false
Hint: Omit it from the simp argument list.
[apply] simp only [hi, hb, hm, decide_true, decide_false, Bool.true_and, Bool.false_and, Bool.and_true]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:174:54: This simp argument is unused:
Bool.true_and
Hint: Omit it from the simp argument list.
[apply] simp only [hi, hb, hm, decide_true, decide_false, Bool.false_and, Bool.and_true, Bool.and_false]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ReflectMathWide.lean:174:85: This simp argument is unused:
Bool.and_true
Hint: Omit it from the simp argument list.
[apply] simp only [hi, hb, hm, decide_true, decide_false, Bool.true_and, Bool.false_and, Bool.and_false]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1844/1893] Built Stage2Proofs.Public32 (11s)
✔ [1845/1893] Built Stage2Proofs.Public16 (11s)
✔ [1846/1893] Built Stage2Proofs.NoTable16 (12s)
✔ [1847/1893] Built Stage2Proofs.NoTable32 (12s)
⚠ [1848/1893] Built Stage2Proofs.WidthEncoding (9.6s)
warning: Stage2Proofs/WidthEncoding.lean:27:36: This simp argument is unused:
BitVec.getLsbD_setWidth
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_shiftLeft, hi, hlo, show i < N - w + 1 by omega]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEncoding.lean:32:12: This simp argument is unused:
BitVec.getLsbD_shiftLeft
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_setWidth, hi, hlo, hbit, show ¬(i - (N - w) = 0) by omega, show ¬(i ≤ N - w) by omega,
show ¬i < N - w + 1 by omega, show i - (N - w + 1) < w by omega, hind]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEncoding.lean:32:38: This simp argument is unused:
BitVec.getLsbD_setWidth
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_shiftLeft, hi, hlo, hbit, show ¬(i - (N - w) = 0) by omega, show ¬(i ≤ N - w) by omega,
show ¬i < N - w + 1 by omega, show i - (N - w + 1) < w by omega, hind]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEncoding.lean:33:36: This simp argument is unused:
show ¬(i ≤ N - w) by omega
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_shiftLeft, BitVec.getLsbD_setWidth, hi, hlo, hbit, show ¬(i - (N - w) = 0) by omega,
show ¬i < N - w + 1 by omega, show i - (N - w + 1) < w by omega, hind]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEncoding.lean:45:49: This simp argument is unused:
h
Hint: Omit it from the simp argument list.
[apply] simp [encode]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1849/1893] Built Stage2Proofs.ReflectedNoTable8 (9.7s)
✔ [1850/1893] Built Stage2Proofs.Constructor8 (10s)
✔ [1851/1893] Built Stage2Proofs.NoTable8Refout (9.2s)
✔ [1852/1893] Built Stage2Proofs.ReflectedConstructor8 (11s)
✔ [1853/1893] Built Stage2Proofs.FullWidthSpec (9.4s)
⚠ [1854/1893] Built Stage2Proofs.ByteIndex (9.7s)
warning: Stage2Proofs/ByteIndex.lean:13:40: This simp argument is unused:
hs
Hint: Omit it from the simp argument list.
[apply] simp [CrcReflectedWide.lowByte, hi, hb, hbN, ← BitVec.getLsbD_eq_getElem]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:13:53: This simp argument is unused:
← BitVec.getLsbD_eq_getElem
Hint: Omit it from the simp argument list.
[apply] simp [CrcReflectedWide.lowByte, hi, hs, hb, hbN]
Note: Simp arguments with `←` have the additional effect of removing the other direction from the simp set, even if the simp argument itself is unused. If the hint above does not work, try replacing `←` with `-` to only get that effect and silence this warning.
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:15:40: This simp argument is unused:
hs
Hint: Omit it from the simp argument list.
[apply] simp [CrcReflectedWide.lowByte, hi, hsmall, ← BitVec.getLsbD_eq_getElem]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:15:52: This simp argument is unused:
← BitVec.getLsbD_eq_getElem
Hint: Omit it from the simp argument list.
[apply] simp [CrcReflectedWide.lowByte, hi, hs, hsmall]
Note: Simp arguments with `←` have the additional effect of removing the other direction from the simp set, even if the simp argument itself is unused. If the hint above does not work, try replacing `←` with `-` to only get that effect and silence this warning.
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:23:35: Variable name `hN` is not explicitly referenced.
Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
[apply] _hN
Note: This linter can be disabled with `set_option linter.unusedVariables false`
warning: Stage2Proofs/ByteIndex.lean:40:10: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:59:70: This simp argument is unused:
hs
Hint: Omit it from the simp argument list.
[apply] simp [CrcCanonicalWide.highPart, CrcCanonicalWide.encodeByte, hi, hb, hidx, show ¬i < N - 8 by omega,
← BitVec.getLsbD_eq_getElem]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:59:74: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp [CrcCanonicalWide.highPart, CrcCanonicalWide.encodeByte, hi, hs, hidx, show ¬i < N - 8 by omega,
← BitVec.getLsbD_eq_getElem]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/ByteIndex.lean:60:30: This simp argument is unused:
← BitVec.getLsbD_eq_getElem
Hint: Omit it from the simp argument list.
[apply] simp [CrcCanonicalWide.highPart, CrcCanonicalWide.encodeByte, hi, hs, hb, hidx, show ¬i < N - 8 by omega]
Note: Simp arguments with `←` have the additional effect of removing the other direction from the simp set, even if the simp argument itself is unused. If the hint above does not work, try replacing `←` with `-` to only get that effect and silence this warning.
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
⚠ [1855/1893] Built Stage2Proofs.NoTable128Reflected (10s)
warning: Stage2Proofs/NoTable128Reflected.lean:101:65: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_ushiftRight, BitVec.getLsbD_setWidth]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
⚠ [1856/1893] Built Stage2Proofs.NoTable16Reflected (11s)
warning: Stage2Proofs/NoTable16Reflected.lean:101:65: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_ushiftRight, BitVec.getLsbD_setWidth]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
⚠ [1857/1893] Built Stage2Proofs.NoTable32Reflected (11s)
warning: Stage2Proofs/NoTable32Reflected.lean:101:65: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_ushiftRight, BitVec.getLsbD_setWidth]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
⚠ [1858/1893] Built Stage2Proofs.NoTable64Reflected (11s)
warning: Stage2Proofs/NoTable64Reflected.lean:101:65: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp [BitVec.getLsbD_ushiftRight, BitVec.getLsbD_setWidth]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1859/1893] Built Stage2Proofs.Constructor32 (10s)
✔ [1860/1893] Built Stage2Proofs.Constructor16 (9.8s)
✔ [1861/1893] Built Stage2Proofs.Public32Reflected (10s)
✔ [1862/1893] Built Stage2Proofs.Public16Reflected (10s)
⚠ [1863/1893] Built Stage2Proofs.WidthEndpoints (9.1s)
warning: Stage2Proofs/WidthEndpoints.lean:33:32: This simp argument is unused:
hindexw
Hint: Omit it from the simp argument list.
[apply] simp only [hindex, hindexN, hinverse, ht, hs, hb, decide_true, decide_false, Bool.not_false, Bool.true_and]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEndpoints.lean:33:41: This simp argument is unused:
hinverse
Hint: Omit it from the simp argument list.
[apply] simp only [hindex, hindexN, hindexw, ht, hs, hb, decide_true, decide_false, Bool.not_false, Bool.true_and]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEndpoints.lean:49:31: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp only [hsub, hs, htop, hi, decide_true, decide_false, Bool.not_false, Bool.true_and]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEndpoints.lean:52:31: This simp argument is unused:
hb
Hint: Omit it from the simp argument list.
[apply] simp only [hsub, hs, htop, hz, decide_true, decide_false, Bool.not_false, Bool.false_and]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/WidthEndpoints.lean:52:39: This simp argument is unused:
decide_true
Hint: Omit it from the simp argument list.
[apply] simp only [hsub, hs, htop, hb, hz, decide_false, Bool.not_false, Bool.false_and]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1864/1893] Built Stage2Proofs.FullWidth8 (8.5s)
✔ [1865/1893] Built Stage2Proofs.Public128 (8.1s)
✔ [1866/1893] Built Stage2Proofs.NoTable128 (9.2s)
✔ [1867/1893] Built Stage2Proofs.NoTableConstructor16 (8.1s)
✔ [1868/1893] Built Stage2Proofs.PartialSpec (7.2s)
✔ [1869/1893] Built Stage2Proofs.ReflectedConstructor32 (8.5s)
✔ [1870/1893] Built Stage2Proofs.ReflectedConstructor16 (8.2s)
✔ [1871/1893] Built Stage2Proofs.Public128Reflected (7.7s)
✔ [1872/1893] Built Stage2Proofs.Constructor128 (8.7s)
✔ [1873/1893] Built Stage2Proofs.Partial8 (7.9s)
✔ [1874/1893] Built Stage2Proofs.FullWidth32 (7.6s)
✔ [1875/1893] Built Stage2Proofs.FullWidth16 (7.8s)
✔ [1876/1893] Built Stage2Proofs.Public64 (52s)
✔ [1877/1893] Built Stage2Proofs.NoTable64 (52s)
✔ [1878/1893] Built Stage2Proofs.ReflectedConstructor128 (7.7s)
✔ [1879/1893] Built Stage2Proofs.PartialConstructor8 (6.4s)
⚠ [1880/1893] Built Stage2Proofs.Partial32 (6.4s)
warning: Stage2Proofs/Partial32.lean:21:13: This simp argument is unused:
Coherent
Hint: Omit it from the simp argument list.
[apply] simp only [CrcPartialSpec.tableEntry, CrcPartialSpec.physical, CrcWidthEndpoints.storedEncode,
CrcPartialSpec.byteStep, hr, Bool.false_eq_true, ↓reduceIte] at h
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/Partial32.lean:34:13: This simp argument is unused:
Coherent
Hint: Omit it from the simp argument list.
[apply] simp only [CrcPartialSpec.tableEntry, CrcPartialSpec.physical, CrcWidthEndpoints.storedEncode,
CrcPartialSpec.byteStep, hr, ↓reduceIte] at h
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1881/1893] Built Stage2Proofs.Partial16 (6.3s)
✔ [1882/1893] Built Stage2Proofs.FullWidth128 (6.5s)
✔ [1883/1893] Built Stage2Proofs.Constructor64 (7.2s)
⚠ [1884/1893] Built Stage2Proofs.PartialConstructor32 (6.7s)
warning: Stage2Proofs/PartialConstructor32.lean:85:5: Variable name `hp` is not explicitly referenced.
Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
[apply] _hp
Note: This linter can be disabled with `set_option linter.unusedVariables false`
✔ [1885/1893] Built Stage2Proofs.PartialConstructor16 (6.5s)
✔ [1886/1893] Built Stage2Proofs.Partial128 (4.0s)
✔ [1887/1893] Built Stage2Proofs.PartialConstructor128 (4.3s)
✔ [1888/1893] Built Stage2Proofs.Public64Reflected (20s)
✔ [1889/1893] Built Stage2Proofs.ReflectedConstructor64 (14s)
✔ [1890/1893] Built Stage2Proofs.FullWidth64 (3.4s)
⚠ [1891/1893] Built Stage2Proofs.Partial64 (3.6s)
warning: Stage2Proofs/Partial64.lean:142:6: Unused tactic linter: `rw [← hcanon]` does nothing.
Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: Stage2Proofs/Partial64.lean:142:21: Unused tactic linter: `exact hstate` does nothing.
Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: Stage2Proofs/Partial64.lean:142:6: this tactic is never executed
Note: This linter can be disabled with `set_option linter.unreachableTactic false`
warning: Stage2Proofs/Partial64.lean:142:21: this tactic is never executed
Note: This linter can be disabled with `set_option linter.unreachableTactic false`
warning: Stage2Proofs/Partial64.lean:171:6: Unused tactic linter: `exact hstate` does nothing.
Note: This linter can be disabled with `set_option linter.unusedTactic false`
⚠ [1892/1893] Built Stage2Proofs.PartialConstructor64 (3.4s)
warning: Stage2Proofs/PartialConstructor64.lean:37:31: This simp argument is unused:
CrcReflectedTable64.Coherent
Hint: Omit it from the simp argument list.
[apply] simp only [CrcPartial64.Coherent, CrcPartial64.withPoly, CrcFullWidth64.Coherent, CrcPublic64.Coherent64, hr,
Bool.false_eq_true, ↓reduceIte]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: Stage2Proofs/PartialConstructor64.lean:49:8: This simp argument is unused:
CrcPublic64.Coherent64
Hint: Omit it from the simp argument list.
[apply] simp only [CrcPartial64.Coherent, CrcPartial64.withPoly, CrcFullWidth64.Coherent,
CrcReflectedTable64.Coherent, hr, ↓reduceIte]
Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
✔ [1893/1893] Built Stage2Proofs.PartialNoTableConstructors (3.6s)
Build completed successfully (1893 jobs).
$ lake env lean --stdin (proofs.rs formal extraction and axiom audit)
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcNoTable16.Digest16","type_segments":[{"ref":"CrcNoTable16.Digest16","text":"CrcNoTable16.Digest16"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 16 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 16 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"16"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]}],"conclusion":"∃ out,\n CrcBody.crc16.DigestAU16Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 16 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.DigestAU16Table.update","text":"CrcBody.crc16.DigestAU16Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"16"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.NoTable16","name":"CrcNoTable16.Digest16","source":{"first_line":122,"last_line":122}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.NoTable16","name":"CrcNoTable16.Crc16._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.NoTable16","name":"CrcNoTable16.Crc16._proof_2","source":null},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.DigestAU16Table.update","source":{"first_line":1894,"last_line":1904}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":246,"last_line":259,"module":"Stage2Proofs.Partial16","program":null,"program_head":null,"statement":"∀ (self : CrcNoTable16.Digest16) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self)))\n state)),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))))\n (@CrcBody.crc16.DigestAU16Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable16.Crc16._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable16.Crc16._proof_1))\n self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial16.digest_update_notable","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartialNoTableConstructors.NoCrc16","type_segments":[{"ref":"CrcPartialNoTableConstructors.NoCrc16","text":"CrcPartialNoTableConstructors.NoCrc16"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.algorithm.poly.bv = BitVec.setWidth 16 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 16 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"xorout"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 16\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.checksum","text":"CrcBody.crc16.CrcU16Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc16","source":{"first_line":48,"last_line":48}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.checksum","source":{"first_line":1839,"last_line":1850}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":240,"last_line":258,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (self : CrcPartialNoTableConstructors.NoCrc16) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) xorout)),\n @Exists.{1} Aeneas.Std.U16 fun (out : Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U16)\n (@CrcBody.crc16.CrcU16Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U16 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))) (Aeneas.Std.U16.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartialNoTableConstructors.checksum16","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U32 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.DigestAU32Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.DigestAU32Table.finalize","text":"CrcBody.crc32.DigestAU32Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.DigestAU32Table.finalize","source":{"first_line":2838,"last_line":2846}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":220,"last_line":226,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1} Aeneas.Std.U32 fun (out : Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U32)\n (@CrcBody.crc32.DigestAU32Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U32 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (Aeneas.Std.U32.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize32_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U128 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U128","type_segments":[{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.digest_with_initial","text":"CrcBody.crc128.CrcU128Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.digest_with_initial","source":{"first_line":960,"last_line":970}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":353,"last_line":360,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U128)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc128.CrcU128Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U128.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial128_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U8 (CrcBody.Table 1#usize) (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.digest_with_initial","text":"CrcBody.crc8.CrcU8Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.digest_with_initial","source":{"first_line":4328,"last_line":4338}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":44,"last_line":51,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U8)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc8.CrcU8Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U8.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial8_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U64 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.DigestAU64Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.DigestAU64Table.finalize","text":"CrcBody.crc64.DigestAU64Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.DigestAU64Table.finalize","source":{"first_line":3776,"last_line":3784}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":287,"last_line":293,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1} Aeneas.Std.U64 fun (out : Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U64)\n (@CrcBody.crc64.DigestAU64Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U64 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))) (Aeneas.Std.U64.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize64_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U64 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.digest","text":"CrcBody.crc64.CrcU64Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.digest","source":{"first_line":3744,"last_line":3752}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":236,"last_line":242,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc64.CrcU64Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest64_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U16 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.digest_with_initial","text":"CrcBody.crc16.CrcU16Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.digest_with_initial","source":{"first_line":1862,"last_line":1872}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":128,"last_line":135,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U16)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc16.CrcU16Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U16.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial16_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcNoTable8.Digest8","type_segments":[{"ref":"CrcNoTable8.Digest8","text":"CrcNoTable8.Digest8"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 8 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 8 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"8"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]}],"conclusion":"∃ out,\n CrcBody.crc8.DigestAU8Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 8 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.DigestAU8Table.update","text":"CrcBody.crc8.DigestAU8Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"8"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.NoTable8","name":"CrcNoTable8.Digest8","source":{"first_line":92,"last_line":92}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.NoTable8","name":"CrcNoTable8.Crc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.NoTable8","name":"CrcNoTable8.Crc8._proof_2","source":null},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.DigestAU8Table.update","source":{"first_line":4360,"last_line":4370}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":251,"last_line":264,"module":"Stage2Proofs.Partial8","program":null,"program_head":null,"statement":"∀ (self : CrcNoTable8.Digest8) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self)))\n state)),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))))\n (@CrcBody.crc8.DigestAU8Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable8.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable8.Crc8._proof_1))\n self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial8.digest_update_notable","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U32 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.digest","text":"CrcBody.crc32.CrcU32Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.digest","source":{"first_line":2806,"last_line":2814}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":161,"last_line":167,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc32.CrcU32Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest32_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U32","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ self, CrcBody.crc32.CrcU32Table.new 0#usize a = Aeneas.Std.Result.ok self ∧ self.algorithm = a","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":", "},{"ref":"CrcBody.crc32.CrcU32Table.new","text":"CrcBody.crc32.CrcU32Table.new"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc32","source":{"first_line":87,"last_line":87}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.new","source":{"first_line":2125,"last_line":2133}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null}],"definitions_truncated":false,"first_line":120,"last_line":124,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U32)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1} CrcPartialNoTableConstructors.NoCrc32 fun (self : CrcPartialNoTableConstructors.NoCrc32) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc32.CrcU32Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U32)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)\n a)","theorem":"CrcPartialNoTableConstructors.new_total32","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U128","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑a.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"a.poly.bv = BitVec.setWidth 128 poly","type_segments":[{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.new 1#usize a = Aeneas.Std.Result.ok out ∧\n out.algorithm = a ∧ CrcPartial128.Coherent out poly","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.new","text":"CrcBody.crc128.CrcU128Table.new"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"},{"ref":"And","text":" ∧ "},{"ref":"CrcPartial128.Coherent","text":"CrcPartial128.Coherent"},{"text":" "},{"text":"out"},{"text":" "},{"text":"poly"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.Public128","name":"CrcPublic128.Crc128","source":{"first_line":7,"last_line":7}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.new","source":{"first_line":237,"last_line":245}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.Public128","name":"CrcPublic128.Crc128._proof_1","source":null},{"module":"Stage2Proofs.Update128","name":"CrcUpdate128.Table","source":{"first_line":5,"last_line":5}},{"module":"Stage2Proofs.Partial128","name":"CrcPartial128.Coherent","source":{"first_line":9,"last_line":11}}],"definitions_truncated":false,"first_line":18,"last_line":66,"module":"Stage2Proofs.PartialConstructor128","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U128)\n (poly :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a)))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U128 a))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) poly)),\n @Exists.{1} CrcPublic128.Crc128 fun (out : CrcPublic128.Crc128) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc128.CrcU128Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U128)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table out)\n a)\n (@CrcPartial128.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a))\n out poly))","theorem":"CrcPartialConstructor128.new_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPublic64.Crc64","type_segments":[{"ref":"CrcPublic64.Crc64","text":"CrcPublic64.Crc64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.algorithm.poly.bv = BitVec.setWidth 64 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 64 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"xorout"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial64.Coherent self poly","type_segments":[{"ref":"CrcPartial64.Coherent","text":"CrcPartial64.Coherent"},{"text":" "},{"text":"self"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 64\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.checksum","text":"CrcBody.crc64.CrcU64Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Public64","name":"CrcPublic64.Crc64","source":{"first_line":6,"last_line":6}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Stage2Proofs.Public64","name":"CrcPublic64.Crc64._proof_1","source":null},{"module":"Stage2Proofs.Update64","name":"CrcUpdate64.Table","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Stage2Proofs.Partial64","name":"CrcPartial64.Coherent","source":{"first_line":13,"last_line":14}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.checksum","source":{"first_line":3709,"last_line":3720}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":155,"last_line":183,"module":"Stage2Proofs.Partial64","program":null,"program_head":null,"statement":"∀ (self : CrcPublic64.Crc64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))))\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) xorout))\n (ht :\n @CrcPartial64.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n self poly)\n (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1} Aeneas.Std.U64 fun (out : Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U64)\n (@CrcBody.crc64.CrcU64Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U64 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))) (Aeneas.Std.U64.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartial64.checksum_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartial32.Digest32","type_segments":[{"ref":"CrcPartial32.Digest32","text":"CrcPartial32.Digest32"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 32 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 32 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"32"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial32.Coherent self.crc poly","type_segments":[{"ref":"CrcPartial32.Coherent","text":"CrcPartial32.Coherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc32.DigestAU32Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 32 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.DigestAU32Table.update","text":"CrcBody.crc32.DigestAU32Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"32"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Partial32","name":"CrcPartial32.Digest32","source":{"first_line":7,"last_line":7}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public32","name":"CrcPublic32.Crc32._proof_1","source":null},{"module":"Stage2Proofs.Update32","name":"CrcUpdate32.Table","source":{"first_line":5,"last_line":5}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Stage2Proofs.Partial32","name":"CrcPartial32.Coherent","source":{"first_line":9,"last_line":11}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.DigestAU32Table.update","source":{"first_line":2826,"last_line":2836}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":73,"last_line":84,"module":"Stage2Proofs.Partial32","program":null,"program_head":null,"statement":"∀ (self : CrcPartial32.Digest32) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n state))\n (ht :\n @CrcPartial32.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)\n poly),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))))\n (@CrcBody.crc32.DigestAU32Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial32.digest_update_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartialNoTableConstructors.NoCrc128","type_segments":[{"ref":"CrcPartialNoTableConstructors.NoCrc128","text":"CrcPartialNoTableConstructors.NoCrc128"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.algorithm.poly.bv = BitVec.setWidth 128 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 128 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"xorout"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 128\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.checksum","text":"CrcBody.crc128.CrcU128Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc128","source":{"first_line":165,"last_line":165}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.checksum","source":{"first_line":937,"last_line":948}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":348,"last_line":366,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (self : CrcPartialNoTableConstructors.NoCrc128) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) xorout)),\n @Exists.{1} Aeneas.Std.U128 fun (out : Aeneas.Std.U128) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U128)\n (@CrcBody.crc128.CrcU128Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U128 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))) (Aeneas.Std.U128.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartialNoTableConstructors.checksum128","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U128","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ self, CrcBody.crc128.CrcU128Table.new 0#usize a = Aeneas.Std.Result.ok self ∧ self.algorithm = a","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":", "},{"ref":"CrcBody.crc128.CrcU128Table.new","text":"CrcBody.crc128.CrcU128Table.new"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc128","source":{"first_line":165,"last_line":165}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.new","source":{"first_line":237,"last_line":245}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null}],"definitions_truncated":false,"first_line":198,"last_line":202,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U128)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1} CrcPartialNoTableConstructors.NoCrc128 fun (self : CrcPartialNoTableConstructors.NoCrc128) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc128.CrcU128Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U128)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)\n a)","theorem":"CrcPartialNoTableConstructors.new_total128","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U16 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.DigestAU16Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.DigestAU16Table.finalize","text":"CrcBody.crc16.DigestAU16Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.DigestAU16Table.finalize","source":{"first_line":1906,"last_line":1914}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":137,"last_line":143,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1} Aeneas.Std.U16 fun (out : Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U16)\n (@CrcBody.crc16.DigestAU16Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U16 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))) (Aeneas.Std.U16.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize16_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U8 (CrcBody.Table 0#usize) (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.digest","text":"CrcBody.crc8.CrcU8Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.digest","source":{"first_line":4340,"last_line":4348}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":11,"last_line":17,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc8.CrcU8Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest8_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U32 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.digest_with_initial","text":"CrcBody.crc32.CrcU32Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.digest_with_initial","source":{"first_line":2794,"last_line":2804}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":203,"last_line":210,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U32)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc32.CrcU32Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U32.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial32_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartialNoTableConstructors.NoCrc8","type_segments":[{"ref":"CrcPartialNoTableConstructors.NoCrc8","text":"CrcPartialNoTableConstructors.NoCrc8"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.algorithm.poly.bv = BitVec.setWidth 8 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 8 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"xorout"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 8\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.checksum","text":"CrcBody.crc8.CrcU8Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8","source":{"first_line":9,"last_line":9}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.checksum","source":{"first_line":4305,"last_line":4316}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":204,"last_line":222,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (self : CrcPartialNoTableConstructors.NoCrc8) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) xorout)),\n @Exists.{1} Aeneas.Std.U8 fun (out : Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U8)\n (@CrcBody.crc8.CrcU8Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U8 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))) (Aeneas.Std.U8.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartialNoTableConstructors.checksum8","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U16","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑a.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"a.poly.bv = BitVec.setWidth 16 poly","type_segments":[{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ self,\n CrcBody.crc16.CrcU16Table.new 1#usize a = Aeneas.Std.Result.ok self ∧\n self.algorithm = a ∧ CrcPartial16.TableCoherent a.refin poly self.data","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.new","text":"CrcBody.crc16.CrcU16Table.new"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"},{"ref":"And","text":" ∧ "},{"ref":"CrcPartial16.TableCoherent","text":"CrcPartial16.TableCoherent"},{"text":" "},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.data","text":"data"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.Public16","name":"CrcPublic16.Crc16","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.new","source":{"first_line":1223,"last_line":1231}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.Public16","name":"CrcPublic16.Crc16._proof_1","source":null},{"module":"Stage2Proofs.Update16","name":"CrcUpdate16.Table","source":{"first_line":5,"last_line":5}},{"module":"Stage2Proofs.Partial16","name":"CrcPartial16.TableCoherent","source":{"first_line":7,"last_line":8}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.Crc.data","source":{"first_line":43,"last_line":43}}],"definitions_truncated":false,"first_line":25,"last_line":60,"module":"Stage2Proofs.PartialConstructor16","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U16)\n (poly :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a)))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U16 a))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) poly)),\n @Exists.{1} CrcPublic16.Crc16 fun (self : CrcPublic16.Crc16) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc16.CrcU16Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (And\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U16)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)\n a)\n (@CrcPartial16.TableCoherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16 a) poly\n (@CrcBody.Crc.data.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))","theorem":"CrcPartialConstructor16.new_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U8 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.DigestAU8Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.DigestAU8Table.finalize","text":"CrcBody.crc8.DigestAU8Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.DigestAU8Table.finalize","source":{"first_line":4372,"last_line":4380}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":78,"last_line":84,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1} Aeneas.Std.U8 fun (out : Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U8)\n (@CrcBody.crc8.DigestAU8Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U8 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))) (Aeneas.Std.U8.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize8_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U16 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.DigestAU16Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.DigestAU16Table.finalize","text":"CrcBody.crc16.DigestAU16Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.DigestAU16Table.finalize","source":{"first_line":1906,"last_line":1914}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":153,"last_line":159,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1} Aeneas.Std.U16 fun (out : Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U16)\n (@CrcBody.crc16.DigestAU16Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U16 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))) (Aeneas.Std.U16.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize16_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U64 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.digest_with_initial","text":"CrcBody.crc64.CrcU64Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.digest_with_initial","source":{"first_line":3732,"last_line":3742}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":269,"last_line":276,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc64.CrcU64Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U64.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial64_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U128 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U128","type_segments":[{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.digest_with_initial","text":"CrcBody.crc128.CrcU128Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.digest_with_initial","source":{"first_line":960,"last_line":970}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":344,"last_line":351,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U128)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc128.CrcU128Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U128.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial128_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U8 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.digest_with_initial","text":"CrcBody.crc8.CrcU8Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.digest_with_initial","source":{"first_line":4328,"last_line":4338}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":53,"last_line":60,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U8)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc8.CrcU8Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U8.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial8_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U8 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.digest","text":"CrcBody.crc8.CrcU8Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.digest","source":{"first_line":4340,"last_line":4348}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":27,"last_line":33,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc8.CrcU8Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest8_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U64","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ self, CrcBody.crc64.CrcU64Table.new 0#usize a = Aeneas.Std.Result.ok self ∧ self.algorithm = a","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":", "},{"ref":"CrcBody.crc64.CrcU64Table.new","text":"CrcBody.crc64.CrcU64Table.new"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc64","source":{"first_line":126,"last_line":126}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.new","source":{"first_line":3057,"last_line":3065}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null}],"definitions_truncated":false,"first_line":159,"last_line":163,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1} CrcPartialNoTableConstructors.NoCrc64 fun (self : CrcPartialNoTableConstructors.NoCrc64) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc64.CrcU64Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U64)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)\n a)","theorem":"CrcPartialNoTableConstructors.new_total64","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U16 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.DigestAU16Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.DigestAU16Table.finalize","text":"CrcBody.crc16.DigestAU16Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.DigestAU16Table.finalize","source":{"first_line":1906,"last_line":1914}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":145,"last_line":151,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1} Aeneas.Std.U16 fun (out : Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U16)\n (@CrcBody.crc16.DigestAU16Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U16 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))) (Aeneas.Std.U16.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize16_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U128 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U128","type_segments":[{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.digest_with_initial","text":"CrcBody.crc128.CrcU128Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.digest_with_initial","source":{"first_line":960,"last_line":970}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":335,"last_line":342,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U128)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc128.CrcU128Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U128.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial128_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U16","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ self, CrcBody.crc16.CrcU16Table.new 0#usize a = Aeneas.Std.Result.ok self ∧ self.algorithm = a","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":", "},{"ref":"CrcBody.crc16.CrcU16Table.new","text":"CrcBody.crc16.CrcU16Table.new"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc16","source":{"first_line":48,"last_line":48}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.new","source":{"first_line":1223,"last_line":1231}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null}],"definitions_truncated":false,"first_line":81,"last_line":85,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U16)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1} CrcPartialNoTableConstructors.NoCrc16 fun (self : CrcPartialNoTableConstructors.NoCrc16) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc16.CrcU16Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U16)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)\n a)","theorem":"CrcPartialNoTableConstructors.new_total16","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U64 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.digest_with_initial","text":"CrcBody.crc64.CrcU64Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.digest_with_initial","source":{"first_line":3732,"last_line":3742}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":260,"last_line":267,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc64.CrcU64Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U64.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial64_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcNoTable64.Digest64","type_segments":[{"ref":"CrcNoTable64.Digest64","text":"CrcNoTable64.Digest64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 64 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 64 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"64"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n CrcBody.crc64.DigestAU64Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 64 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.DigestAU64Table.update","text":"CrcBody.crc64.DigestAU64Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"64"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.NoTable64","name":"CrcNoTable64.Digest64","source":{"first_line":122,"last_line":122}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Stage2Proofs.NoTable64","name":"CrcNoTable64.Crc64._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.NoTable64","name":"CrcNoTable64.Crc64._proof_2","source":null},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.DigestAU64Table.update","source":{"first_line":3764,"last_line":3774}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":200,"last_line":213,"module":"Stage2Proofs.Partial64","program":null,"program_head":null,"statement":"∀ (self : CrcNoTable64.Digest64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))))\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self)))\n state))\n (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))))\n (@CrcBody.crc64.DigestAU64Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable64.Crc64._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable64.Crc64._proof_1))\n self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial64.digest_update_notable","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U32 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.digest_with_initial","text":"CrcBody.crc32.CrcU32Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.digest_with_initial","source":{"first_line":2794,"last_line":2804}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":194,"last_line":201,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U32)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc32.CrcU32Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U32.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial32_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U128 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.DigestAU128Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.DigestAU128Table.finalize","text":"CrcBody.crc128.DigestAU128Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.DigestAU128Table.finalize","source":{"first_line":1004,"last_line":1012}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":378,"last_line":384,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1} Aeneas.Std.U128 fun (out : Aeneas.Std.U128) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U128)\n (@CrcBody.crc128.DigestAU128Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U128 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))) (Aeneas.Std.U128.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize128_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U16 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.digest","text":"CrcBody.crc16.CrcU16Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.digest","source":{"first_line":1874,"last_line":1882}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":86,"last_line":92,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc16.CrcU16Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest16_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartial32.Crc32","type_segments":[{"ref":"CrcPartial32.Crc32","text":"CrcPartial32.Crc32"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.algorithm.poly.bv = BitVec.setWidth 32 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 32 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"xorout"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial32.Coherent self poly","type_segments":[{"ref":"CrcPartial32.Coherent","text":"CrcPartial32.Coherent"},{"text":" "},{"text":"self"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 32\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.checksum","text":"CrcBody.crc32.CrcU32Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Partial32","name":"CrcPartial32.Crc32","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public32","name":"CrcPublic32.Crc32._proof_1","source":null},{"module":"Stage2Proofs.Update32","name":"CrcUpdate32.Table","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Stage2Proofs.Partial32","name":"CrcPartial32.Coherent","source":{"first_line":9,"last_line":11}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.checksum","source":{"first_line":2771,"last_line":2782}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":86,"last_line":109,"module":"Stage2Proofs.Partial32","program":null,"program_head":null,"statement":"∀ (self : CrcPartial32.Crc32) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) xorout))\n (ht :\n @CrcPartial32.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n self poly),\n @Exists.{1} Aeneas.Std.U32 fun (out : Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U32)\n (@CrcBody.crc32.CrcU32Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U32 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (Aeneas.Std.U32.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self)))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartial32.checksum_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U16 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.digest_with_initial","text":"CrcBody.crc16.CrcU16Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.digest_with_initial","source":{"first_line":1862,"last_line":1872}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":110,"last_line":117,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U16)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc16.CrcU16Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U16.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial16_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U128 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.digest","text":"CrcBody.crc128.CrcU128Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.digest","source":{"first_line":972,"last_line":980}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":327,"last_line":333,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc128.CrcU128Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest128_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U32 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U32","type_segments":[{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.digest_with_initial","text":"CrcBody.crc32.CrcU32Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.digest_with_initial","source":{"first_line":2794,"last_line":2804}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":185,"last_line":192,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U32)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc32.CrcU32Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U32.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial32_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartialNoTableConstructors.NoCrc32","type_segments":[{"ref":"CrcPartialNoTableConstructors.NoCrc32","text":"CrcPartialNoTableConstructors.NoCrc32"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.algorithm.poly.bv = BitVec.setWidth 32 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 32 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"xorout"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 32\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.checksum","text":"CrcBody.crc32.CrcU32Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc32","source":{"first_line":87,"last_line":87}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.checksum","source":{"first_line":2771,"last_line":2782}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":276,"last_line":294,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (self : CrcPartialNoTableConstructors.NoCrc32) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) xorout)),\n @Exists.{1} Aeneas.Std.U32 fun (out : Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U32)\n (@CrcBody.crc32.CrcU32Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U32 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (Aeneas.Std.U32.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartialNoTableConstructors.checksum32","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartialNoTableConstructors.NoCrc64","type_segments":[{"ref":"CrcPartialNoTableConstructors.NoCrc64","text":"CrcPartialNoTableConstructors.NoCrc64"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.algorithm.poly.bv = BitVec.setWidth 64 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 64 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"xorout"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 64\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.checksum","text":"CrcBody.crc64.CrcU64Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc64","source":{"first_line":126,"last_line":126}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.checksum","source":{"first_line":3709,"last_line":3720}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":312,"last_line":330,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (self : CrcPartialNoTableConstructors.NoCrc64) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) xorout)),\n @Exists.{1} Aeneas.Std.U64 fun (out : Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U64)\n (@CrcBody.crc64.CrcU64Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U64 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))) (Aeneas.Std.U64.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartialNoTableConstructors.checksum64","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U16 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U16","type_segments":[{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.digest_with_initial","text":"CrcBody.crc16.CrcU16Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.digest_with_initial","source":{"first_line":1862,"last_line":1872}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":119,"last_line":126,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U16)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc16.CrcU16Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U16.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial16_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U32 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.digest","text":"CrcBody.crc32.CrcU32Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.digest","source":{"first_line":2806,"last_line":2814}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":177,"last_line":183,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc32.CrcU32Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest32_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U32 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.DigestAU32Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.DigestAU32Table.finalize","text":"CrcBody.crc32.DigestAU32Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.DigestAU32Table.finalize","source":{"first_line":2838,"last_line":2846}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":228,"last_line":234,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1} Aeneas.Std.U32 fun (out : Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U32)\n (@CrcBody.crc32.DigestAU32Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U32 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (Aeneas.Std.U32.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize32_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartial128.Digest128","type_segments":[{"ref":"CrcPartial128.Digest128","text":"CrcPartial128.Digest128"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 128 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 128 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"128"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial128.Coherent self.crc poly","type_segments":[{"ref":"CrcPartial128.Coherent","text":"CrcPartial128.Coherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc128.DigestAU128Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 128 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.DigestAU128Table.update","text":"CrcBody.crc128.DigestAU128Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"128"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Partial128","name":"CrcPartial128.Digest128","source":{"first_line":7,"last_line":7}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public128","name":"CrcPublic128.Crc128._proof_1","source":null},{"module":"Stage2Proofs.Update128","name":"CrcUpdate128.Table","source":{"first_line":5,"last_line":5}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Stage2Proofs.Partial128","name":"CrcPartial128.Coherent","source":{"first_line":9,"last_line":11}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.DigestAU128Table.update","source":{"first_line":992,"last_line":1002}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":73,"last_line":84,"module":"Stage2Proofs.Partial128","program":null,"program_head":null,"statement":"∀ (self : CrcPartial128.Digest128) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n state))\n (ht :\n @CrcPartial128.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)\n poly),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))))\n (@CrcBody.crc128.DigestAU128Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial128.digest_update_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U16 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.digest","text":"CrcBody.crc16.CrcU16Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.digest","source":{"first_line":1874,"last_line":1882}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":102,"last_line":108,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc16.CrcU16Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest16_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U64 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.digest","text":"CrcBody.crc64.CrcU64Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.digest","source":{"first_line":3744,"last_line":3752}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":244,"last_line":250,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc64.CrcU64Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest64_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U8 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.DigestAU8Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.DigestAU8Table.finalize","text":"CrcBody.crc8.DigestAU8Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.DigestAU8Table.finalize","source":{"first_line":4372,"last_line":4380}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":62,"last_line":68,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1} Aeneas.Std.U8 fun (out : Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U8)\n (@CrcBody.crc8.DigestAU8Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U8 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))) (Aeneas.Std.U8.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize8_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U128 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.DigestAU128Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.DigestAU128Table.finalize","text":"CrcBody.crc128.DigestAU128Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.DigestAU128Table.finalize","source":{"first_line":1004,"last_line":1012}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":370,"last_line":376,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1} Aeneas.Std.U128 fun (out : Aeneas.Std.U128) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U128)\n (@CrcBody.crc128.DigestAU128Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U128 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))) (Aeneas.Std.U128.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize128_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U8","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ self, CrcBody.crc8.CrcU8Table.new 0#usize a = Aeneas.Std.Result.ok self ∧ self.algorithm = a","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":", "},{"ref":"CrcBody.crc8.CrcU8Table.new","text":"CrcBody.crc8.CrcU8Table.new"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8","source":{"first_line":9,"last_line":9}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.new","source":{"first_line":3971,"last_line":3979}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_1","source":null},{"module":"Stage2Proofs.PartialNoTableConstructors","name":"CrcPartialNoTableConstructors.NoCrc8._proof_2","source":null}],"definitions_truncated":false,"first_line":42,"last_line":46,"module":"Stage2Proofs.PartialNoTableConstructors","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U8)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1} CrcPartialNoTableConstructors.NoCrc8 fun (self : CrcPartialNoTableConstructors.NoCrc8) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc8.CrcU8Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U8)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcPartialNoTableConstructors.NoCrc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcPartialNoTableConstructors.NoCrc8._proof_1))\n self)\n a)","theorem":"CrcPartialNoTableConstructors.new_total8","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPublic16.Crc16","type_segments":[{"ref":"CrcPublic16.Crc16","text":"CrcPublic16.Crc16"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.algorithm.poly.bv = BitVec.setWidth 16 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hi","type":"self.algorithm.init.bv = BitVec.setWidth 16 initial","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"initial"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 16 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"xorout"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial16.TableCoherent self.algorithm.refin poly self.data","type_segments":[{"ref":"CrcPartial16.TableCoherent","text":"CrcPartial16.TableCoherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.data","text":"data"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 16\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly initial xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.checksum","text":"CrcBody.crc16.CrcU16Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"initial"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Public16","name":"CrcPublic16.Crc16","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public16","name":"CrcPublic16.Crc16._proof_1","source":null},{"module":"Stage2Proofs.Update16","name":"CrcUpdate16.Table","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Stage2Proofs.Partial16","name":"CrcPartial16.TableCoherent","source":{"first_line":7,"last_line":8}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.Crc.data","source":{"first_line":43,"last_line":43}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.checksum","source":{"first_line":1839,"last_line":1850}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":80,"last_line":101,"module":"Stage2Proofs.Partial16","program":null,"program_head":null,"statement":"∀ (self : CrcPublic16.Crc16) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly initial xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) poly))\n (hi :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) initial))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) xorout))\n (ht :\n @CrcPartial16.TableCoherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))\n poly\n (@CrcBody.Crc.data.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)),\n @Exists.{1} Aeneas.Std.U16 fun (out : Aeneas.Std.U16) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U16)\n (@CrcBody.crc16.CrcU16Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U16 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))) (Aeneas.Std.U16.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))\n poly initial xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartial16.checksum_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U8","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑a.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"a.poly.bv = BitVec.setWidth 8 poly","type_segments":[{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ self,\n CrcBody.crc8.CrcU8Table.new 1#usize a = Aeneas.Std.Result.ok self ∧\n self.algorithm = a ∧ CrcPartial8.TableCoherent a.refin poly self.data","conclusion_segments":[{"text":"∃ "},{"text":"self"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.new","text":"CrcBody.crc8.CrcU8Table.new"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"},{"ref":"And","text":" ∧ "},{"ref":"CrcPartial8.TableCoherent","text":"CrcPartial8.TableCoherent"},{"text":" "},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.data","text":"data"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.new","source":{"first_line":3971,"last_line":3979}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8._proof_1","source":null},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8._proof_2","source":null},{"module":"Stage2Proofs.Partial8","name":"CrcPartial8.TableCoherent","source":{"first_line":7,"last_line":9}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.Crc.data","source":{"first_line":43,"last_line":43}}],"definitions_truncated":false,"first_line":26,"last_line":61,"module":"Stage2Proofs.PartialConstructor8","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U8)\n (poly :\n BitVec (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a)))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U8 a))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) poly)),\n @Exists.{1} CrcBody.Crc8 fun (self : CrcBody.Crc8) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc8.CrcU8Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n self))\n (And\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U8)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)\n a)\n (@CrcPartial8.TableCoherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8 a))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8 a) poly\n (@CrcBody.Crc.data.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))","theorem":"CrcPartialConstructor8.new_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartial32.NoDigest32","type_segments":[{"ref":"CrcPartial32.NoDigest32","text":"CrcPartial32.NoDigest32"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 32 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 32 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"32"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]}],"conclusion":"∃ out,\n CrcBody.crc32.DigestAU32Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 32 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.DigestAU32Table.update","text":"CrcBody.crc32.DigestAU32Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"32"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Partial32","name":"CrcPartial32.NoDigest32","source":{"first_line":112,"last_line":112}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.NoTable32","name":"CrcNoTable32.Crc32._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.NoTable32","name":"CrcNoTable32.Crc32._proof_2","source":null},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.DigestAU32Table.update","source":{"first_line":2826,"last_line":2836}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":170,"last_line":179,"module":"Stage2Proofs.Partial32","program":null,"program_head":null,"statement":"∀ (self : CrcPartial32.NoDigest32) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self)))\n state)),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))))\n (@CrcBody.crc32.DigestAU32Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable32.Crc32._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable32.Crc32._proof_1))\n self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial32.digest_update_notable","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest8","type_segments":[{"ref":"CrcBody.Digest8","text":"CrcBody.Digest8"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 8 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 8 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"8"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial8.TableCoherent self.crc.algorithm.refin poly self.crc.data","type_segments":[{"ref":"CrcPartial8.TableCoherent","text":"CrcPartial8.TableCoherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.data","text":"data"}]}],"conclusion":"∃ out,\n CrcBody.crc8.DigestAU8Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 8 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.DigestAU8Table.update","text":"CrcBody.crc8.DigestAU8Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"8"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Digest8","source":{"first_line":7,"last_line":7}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8._proof_2","source":null},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Stage2Proofs.Partial8","name":"CrcPartial8.TableCoherent","source":{"first_line":7,"last_line":9}},{"module":"CrcBody.Types","name":"CrcBody.Crc.data","source":{"first_line":43,"last_line":43}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.DigestAU8Table.update","source":{"first_line":4360,"last_line":4370}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":108,"last_line":122,"module":"Stage2Proofs.Partial8","program":null,"program_head":null,"statement":"∀ (self : CrcBody.Digest8) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n state))\n (ht :\n @CrcPartial8.TableCoherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n poly\n (@CrcBody.Crc.data.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))))\n (@CrcBody.crc8.DigestAU8Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial8.digest_update_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U128 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.digest","text":"CrcBody.crc128.CrcU128Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.digest","source":{"first_line":972,"last_line":980}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":311,"last_line":317,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc128.CrcU128Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest128_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U8 (CrcBody.Table 0#usize) (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.digest_with_initial","text":"CrcBody.crc8.CrcU8Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.digest_with_initial","source":{"first_line":4328,"last_line":4338}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":35,"last_line":42,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U8)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc8.CrcU8Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U8.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial8_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc8","type_segments":[{"ref":"CrcBody.Crc8","text":"CrcBody.Crc8"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.algorithm.poly.bv = BitVec.setWidth 8 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hi","type":"self.algorithm.init.bv = BitVec.setWidth 8 initial","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"initial"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 8 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":" "},{"text":"xorout"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial8.TableCoherent self.algorithm.refin poly self.data","type_segments":[{"ref":"CrcPartial8.TableCoherent","text":"CrcPartial8.TableCoherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.data","text":"data"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 8\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly initial xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.checksum","text":"CrcBody.crc8.CrcU8Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"8"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"initial"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.Public8Base","name":"CrcBody.Crc8._proof_2","source":null},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Stage2Proofs.Partial8","name":"CrcPartial8.TableCoherent","source":{"first_line":7,"last_line":9}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.Crc.data","source":{"first_line":43,"last_line":43}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.checksum","source":{"first_line":4305,"last_line":4316}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":85,"last_line":106,"module":"Stage2Proofs.Partial8","program":null,"program_head":null,"statement":"∀ (self : CrcBody.Crc8) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly initial xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) poly))\n (hi :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) initial))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))) xorout))\n (ht :\n @CrcPartial8.TableCoherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))\n poly\n (@CrcBody.Crc.data.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1))\n self)),\n @Exists.{1} Aeneas.Std.U8 fun (out : Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U8)\n (@CrcBody.crc8.CrcU8Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1))) CrcBody.Crc8._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U8 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))) (Aeneas.Std.U8.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.Crc8._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcBody.Crc8._proof_1))\n self))\n poly initial xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartial8.checksum_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U8 (CrcBody.Table 1#usize) (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.CrcU8Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.CrcU8Table.digest","text":"CrcBody.crc8.CrcU8Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.CrcU8Table.digest","source":{"first_line":4340,"last_line":4348}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":19,"last_line":25,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc8.CrcU8Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest8_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U16 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U16 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U16","text":"Aeneas.Std.U16"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]}],"conclusion":"∃ out,\n CrcBody.crc16.CrcU16Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.CrcU16Table.digest","text":"CrcBody.crc16.CrcU16Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.CrcU16Table.digest","source":{"first_line":1874,"last_line":1882}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":94,"last_line":100,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc16.CrcU16Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest16_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U64 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.DigestAU64Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.DigestAU64Table.finalize","text":"CrcBody.crc64.DigestAU64Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.DigestAU64Table.finalize","source":{"first_line":3776,"last_line":3784}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":303,"last_line":309,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1} Aeneas.Std.U64 fun (out : Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U64)\n (@CrcBody.crc64.DigestAU64Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U64 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))) (Aeneas.Std.U64.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize64_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U32 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.digest","text":"CrcBody.crc32.CrcU32Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.digest","source":{"first_line":2806,"last_line":2814}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":169,"last_line":175,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc32.CrcU32Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest32_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U64 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.DigestAU64Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.DigestAU64Table.finalize","text":"CrcBody.crc64.DigestAU64Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.DigestAU64Table.finalize","source":{"first_line":3776,"last_line":3784}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":295,"last_line":301,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1} Aeneas.Std.U64 fun (out : Aeneas.Std.U64) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U64)\n (@CrcBody.crc64.DigestAU64Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U64 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))) (Aeneas.Std.U64.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize64_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U64 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"variable","name":"initial","type":"Aeneas.Std.U64","type_segments":[{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.digest_with_initial self initial = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧ out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin initial.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.digest_with_initial","text":"CrcBody.crc64.CrcU64Table.digest_with_initial"},{"text":" "},{"text":"self"},{"text":" "},{"text":"initial"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧ "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"initial"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.digest_with_initial","source":{"first_line":3732,"last_line":3742}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}}],"definitions_truncated":false,"first_line":278,"last_line":285,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (initial : Aeneas.Std.U64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc64.CrcU64Table.digest_with_initial\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self initial)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U64.bv initial))))","theorem":"CrcPublicWordInstances.digest_with_initial64_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U128 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.DigestAU128Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.DigestAU128Table.finalize","text":"CrcBody.crc128.DigestAU128Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.DigestAU128Table.finalize","source":{"first_line":1004,"last_line":1012}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":362,"last_line":368,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1} Aeneas.Std.U128 fun (out : Aeneas.Std.U128) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U128)\n (@CrcBody.crc128.DigestAU128Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U128 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))) (Aeneas.Std.U128.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize128_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPublic16.Digest16","type_segments":[{"ref":"CrcPublic16.Digest16","text":"CrcPublic16.Digest16"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 16","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"16"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 16 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"16"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 16 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"16"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial16.TableCoherent self.crc.algorithm.refin poly self.crc.data","type_segments":[{"ref":"CrcPartial16.TableCoherent","text":"CrcPartial16.TableCoherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.data","text":"data"}]}],"conclusion":"∃ out,\n CrcBody.crc16.DigestAU16Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 16 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc16.DigestAU16Table.update","text":"CrcBody.crc16.DigestAU16Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U16.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"16"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Public16","name":"CrcPublic16.Digest16","source":{"first_line":7,"last_line":7}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16","source":{"first_line":670,"last_line":670}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public16","name":"CrcPublic16.Crc16._proof_1","source":null},{"module":"Stage2Proofs.Update16","name":"CrcUpdate16.Table","source":{"first_line":5,"last_line":5}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U16.bv","source":{"first_line":1108,"last_line":1108}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Stage2Proofs.Partial16","name":"CrcPartial16.TableCoherent","source":{"first_line":7,"last_line":8}},{"module":"CrcBody.Types","name":"CrcBody.Crc.data","source":{"first_line":43,"last_line":43}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc16.DigestAU16Table.update","source":{"first_line":1894,"last_line":1904}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":104,"last_line":118,"module":"Stage2Proofs.Partial16","program":null,"program_head":null,"statement":"∀ (self : CrcPublic16.Digest16) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n state))\n (ht :\n @CrcPartial16.TableCoherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n poly\n (@CrcBody.Crc.data.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))))\n (@CrcBody.crc16.DigestAU16Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16))))\n (Aeneas.Std.U16.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U16\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U16\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U16\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic16.Crc16._proof_1))\n CrcUpdate16.Table self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial16.digest_update_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U128 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U128 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U128","text":"Aeneas.Std.U128"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.digest","text":"CrcBody.crc128.CrcU128Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.digest","source":{"first_line":972,"last_line":980}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":319,"last_line":325,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc128.CrcU128Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest128_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Crc Aeneas.Std.U64 (CrcBody.Table 16#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U64 256#usize) 16#usize)","type_segments":[{"ref":"CrcBody.Crc","text":"CrcBody.Crc"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"16"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.digest self = Aeneas.Std.Result.ok out ∧\n out.crc = self ∧\n out.value.bv = CrcStage2.rawInit (↑self.algorithm.width) self.algorithm.refin self.algorithm.init.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.digest","text":"CrcBody.crc64.CrcU64Table.digest"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcStage2.rawInit","text":"CrcStage2.rawInit"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.digest","source":{"first_line":3744,"last_line":3752}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawInit","source":{"first_line":69,"last_line":70}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}}],"definitions_truncated":false,"first_line":252,"last_line":258,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (@CrcBody.crc64.CrcU64Table.digest\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out)\n self)\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n out))\n (@CrcStage2.rawInit (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 16) (instOfNatNat (nat_lit 16)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))))","theorem":"CrcPublicWordInstances.digest64_lane16_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPublic64.Digest64","type_segments":[{"ref":"CrcPublic64.Digest64","text":"CrcPublic64.Digest64"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 64 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial64.Coherent self.crc poly","type_segments":[{"ref":"CrcPartial64.Coherent","text":"CrcPartial64.Coherent"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 64 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"64"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]}],"conclusion":"∃ out,\n CrcBody.crc64.DigestAU64Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 64 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.DigestAU64Table.update","text":"CrcBody.crc64.DigestAU64Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"64"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Public64","name":"CrcPublic64.Digest64","source":{"first_line":7,"last_line":7}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Stage2Proofs.Public64","name":"CrcPublic64.Crc64._proof_1","source":null},{"module":"Stage2Proofs.Update64","name":"CrcUpdate64.Table","source":{"first_line":5,"last_line":5}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"Stage2Proofs.Partial64","name":"CrcPartial64.Coherent","source":{"first_line":13,"last_line":14}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc64.DigestAU64Table.update","source":{"first_line":3764,"last_line":3774}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":184,"last_line":198,"module":"Stage2Proofs.Partial64","program":null,"program_head":null,"statement":"∀ (self : CrcPublic64.Digest64)\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))))\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) poly))\n (ht :\n @CrcPartial64.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)\n poly)\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n state))\n (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))))\n (@CrcBody.crc64.DigestAU64Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U64\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial64.digest_update_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U32 (CrcBody.Table 0#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U32 256#usize) 0#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"0"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]}],"conclusion":"∃ out,\n CrcBody.crc32.DigestAU32Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.DigestAU32Table.finalize","text":"CrcBody.crc32.DigestAU32Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc32.DigestAU32Table.finalize","source":{"first_line":2838,"last_line":2846}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":212,"last_line":218,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))),\n @Exists.{1} Aeneas.Std.U32 fun (out : Aeneas.Std.U32) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U32)\n (@CrcBody.crc32.DigestAU32Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U32 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))) (Aeneas.Std.U32.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U32.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U32\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U32.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize32_lane0_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcBody.Digest Aeneas.Std.U8 (CrcBody.Table 1#usize)\n (Aeneas.Std.Array (Aeneas.Std.Array Aeneas.Std.U8 256#usize) 1#usize)","type_segments":[{"ref":"CrcBody.Digest","text":"CrcBody.Digest"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"("},{"ref":"CrcBody.Table","text":"CrcBody.Table"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":"\n "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"text":"("},{"ref":"Aeneas.Std.Array","text":"Aeneas.Std.Array"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"},{"text":" "},{"text":"256"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":")"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 8","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"8"}]}],"conclusion":"∃ out,\n CrcBody.crc8.DigestAU8Table.finalize self = Aeneas.Std.Result.ok out ∧\n out.bv =\n CrcStage2.rawFinalize (↑self.crc.algorithm.width) self.crc.algorithm.refin self.crc.algorithm.refout\n self.crc.algorithm.xorout.bv self.value.bv","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc8.DigestAU8Table.finalize","text":"CrcBody.crc8.DigestAU8Table.finalize"},{"text":" "},{"text":"self"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcStage2.rawFinalize","text":"CrcStage2.rawFinalize"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":"\n "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U8.bv","text":"bv"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc8.DigestAU8Table.finalize","source":{"first_line":4372,"last_line":4380}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8.bv","source":{"first_line":1107,"last_line":1107}},{"module":"Stage2Proofs.InitFinalize","name":"CrcStage2.rawFinalize","source":{"first_line":72,"last_line":74}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}}],"definitions_truncated":false,"first_line":70,"last_line":76,"module":"Stage2Proofs.WordProtocolInstances","program":null,"program_head":null,"statement":"∀\n (self :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))),\n @Exists.{1} Aeneas.Std.U8 fun (out : Aeneas.Std.U8) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U8)\n (@CrcBody.crc8.DigestAU8Table.finalize\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n self)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U8 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))) (Aeneas.Std.U8.bv out)\n (@CrcStage2.rawFinalize (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self)))\n (Aeneas.Std.U8.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U8\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat\n (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))\n (Aeneas.Std.U8.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U8\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U8\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n self))))","theorem":"CrcPublicWordInstances.digest_finalize8_lane1_spec","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcPartial128.Crc128","type_segments":[{"ref":"CrcPartial128.Crc128","text":"CrcPartial128.Crc128"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"xorout","type":"BitVec ↑self.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.algorithm.width ∧ ↑self.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]},{"binder":"explicit","kind":"hypothesis","name":"_hp","type":"self.algorithm.poly.bv = BitVec.setWidth 128 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hx","type":"self.algorithm.xorout.bv = BitVec.setWidth 128 xorout","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.xorout","text":"xorout"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"xorout"}]},{"binder":"explicit","kind":"hypothesis","name":"ht","type":"CrcPartial128.Coherent self poly","type_segments":[{"ref":"CrcPartial128.Coherent","text":"CrcPartial128.Coherent"},{"text":" "},{"text":"self"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc128.CrcU128Table.checksum self bytes = Aeneas.Std.Result.ok out ∧\n out.bv =\n BitVec.setWidth 128\n (CrcPartialSpec.checksum self.algorithm.refin self.algorithm.refout poly\n (BitVec.setWidth (↑self.algorithm.width) self.algorithm.init.bv) xorout\n (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.CrcU128Table.checksum","text":"CrcBody.crc128.CrcU128Table.checksum"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.checksum","text":"CrcPartialSpec.checksum"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refout","text":"refout"},{"text":" "},{"text":"poly"},{"text":"\n "},{"text":"("},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"(↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"text":")"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.init","text":"init"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"text":")"},{"text":" "},{"text":"xorout"},{"text":"\n "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.Partial128","name":"CrcPartial128.Crc128","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.Public128","name":"CrcPublic128.Crc128._proof_1","source":null},{"module":"Stage2Proofs.Update128","name":"CrcUpdate128.Table","source":{"first_line":5,"last_line":5}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.xorout","source":{"first_line":34,"last_line":34}},{"module":"Stage2Proofs.Partial128","name":"CrcPartial128.Coherent","source":{"first_line":9,"last_line":11}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.CrcU128Table.checksum","source":{"first_line":937,"last_line":948}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.checksum","source":{"first_line":19,"last_line":19}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refout","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.init","source":{"first_line":31,"last_line":31}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":86,"last_line":109,"module":"Stage2Proofs.Partial128","program":null,"program_head":null,"statement":"∀ (self : CrcPartial128.Crc128) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly xorout :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))))\n (_hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) poly))\n (hx :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.xorout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) xorout))\n (ht :\n @CrcPartial128.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n self poly),\n @Exists.{1} Aeneas.Std.U128 fun (out : Aeneas.Std.U128) =>\n And\n (@Eq.{1} (Aeneas.Std.Result.{0} Aeneas.Std.U128)\n (@CrcBody.crc128.CrcU128Table.checksum\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0} Aeneas.Std.U128 out))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))) (Aeneas.Std.U128.bv out)\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@CrcPartialSpec.checksum\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))\n (@CrcBody.crc_catalog.Algorithm.refout.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))\n poly\n (@BitVec.setWidth (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self)))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.init.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic128.Crc128._proof_1))\n CrcUpdate128.Table self))))\n xorout\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes)))))","theorem":"CrcPartial128.checksum_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"self","type":"CrcNoTable128.Digest128","type_segments":[{"ref":"CrcNoTable128.Digest128","text":"CrcNoTable128.Digest128"}]},{"binder":"explicit","kind":"variable","name":"bytes","type":"Aeneas.Std.Slice Aeneas.Std.U8","type_segments":[{"ref":"Aeneas.Std.Slice","text":"Aeneas.Std.Slice"},{"text":" "},{"ref":"Aeneas.Std.U8","text":"Aeneas.Std.U8"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"variable","name":"state","type":"BitVec ↑self.crc.algorithm.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑self.crc.algorithm.width ∧ ↑self.crc.algorithm.width ≤ 128","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"128"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"self.crc.algorithm.poly.bv = BitVec.setWidth 128 poly","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"128"},{"text":" "},{"text":"poly"}]},{"binder":"explicit","kind":"hypothesis","name":"hs","type":"self.value.bv = CrcPartialSpec.physical 128 self.crc.algorithm.refin state","type_segments":[{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"128"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"state"}]}],"conclusion":"∃ out,\n CrcBody.crc128.DigestAU128Table.update self bytes = Aeneas.Std.Result.ok out ∧\n out.crc = self.crc ∧\n out.value.bv =\n CrcPartialSpec.physical 128 self.crc.algorithm.refin\n (CrcPartialSpec.run self.crc.algorithm.refin poly state (List.map Aeneas.Std.UScalar.bv ↑bytes))","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc128.DigestAU128Table.update","text":"CrcBody.crc128.DigestAU128Table.update"},{"text":" "},{"text":"self"},{"text":" "},{"text":"bytes"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"Eq","text":" = "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Digest.value","text":"value"},{"text":"."},{"ref":"Aeneas.Std.U128.bv","text":"bv"},{"ref":"Eq","text":" =\n "},{"ref":"CrcPartialSpec.physical","text":"CrcPartialSpec.physical"},{"text":" "},{"text":"128"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":"\n "},{"text":"("},{"ref":"CrcPartialSpec.run","text":"CrcPartialSpec.run"},{"text":" "},{"text":"self"},{"text":"."},{"ref":"CrcBody.Digest.crc","text":"crc"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.refin","text":"refin"},{"text":" "},{"text":"poly"},{"text":" "},{"text":"state"},{"text":" "},{"text":"("},{"ref":"List.map","text":"List.map"},{"text":" "},{"ref":"Aeneas.Std.UScalar.bv","text":"Aeneas.Std.UScalar.bv"},{"text":" "},{"text":"↑"},{"text":"bytes"},{"text":")"},{"text":")"}],"definitions":[{"module":"Stage2Proofs.NoTable128","name":"CrcNoTable128.Digest128","source":{"first_line":120,"last_line":120}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice","source":{"first_line":15,"last_line":19}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U8","source":{"first_line":669,"last_line":669}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128","source":{"first_line":673,"last_line":673}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Stage2Proofs.NoTable128","name":"CrcNoTable128.Crc128._proof_1","source":null},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"Stage2Proofs.NoTable128","name":"CrcNoTable128.Crc128._proof_2","source":null},{"module":"CrcBody.Types","name":"CrcBody.Digest.crc","source":{"first_line":55,"last_line":55}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U128.bv","source":{"first_line":1111,"last_line":1111}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"CrcBody.Types","name":"CrcBody.Digest.value","source":{"first_line":56,"last_line":56}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.physical","source":{"first_line":5,"last_line":7}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.refin","source":{"first_line":32,"last_line":32}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"CrcBody.Types","name":"CrcBody.Digest","source":{"first_line":51,"last_line":56}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Funs","name":"CrcBody.crc128.DigestAU128Table.update","source":{"first_line":992,"last_line":1002}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"Stage2Proofs.PartialSpec","name":"CrcPartialSpec.run","source":{"first_line":18,"last_line":18}},{"module":"Init.Prelude","name":"List.map","source":{"first_line":3301,"last_line":3314}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.bv","source":{"first_line":73,"last_line":73}},{"module":"Aeneas.Std.SliceDef","name":"Aeneas.Std.Slice.val","source":{"first_line":21,"last_line":22}}],"definitions_truncated":false,"first_line":163,"last_line":173,"module":"Stage2Proofs.Partial128","program":null,"program_head":null,"statement":"∀ (self : CrcNoTable128.Digest128) (bytes : Aeneas.Std.Slice.{0} Aeneas.Std.U8)\n (poly state :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self)))))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self)))))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))) poly))\n (hs :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self)))\n state)),\n @Exists.{1}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1)))\n fun\n (out :\n CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))))\n (@CrcBody.crc128.DigestAU128Table.update\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1)\n self bytes)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Digest.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1)))\n out))\n (And\n (@Eq.{1}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1)))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n out)\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))\n (@Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128))))\n (Aeneas.Std.U128.bv\n (@CrcBody.Digest.value.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n out))\n (@CrcPartialSpec.physical\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))))\n (@OfNat.ofNat.{0} Nat (nat_lit 128) (instOfNatNat (nat_lit 128)))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self)))\n (@CrcPartialSpec.run\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8\n (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self))))\n (@CrcBody.crc_catalog.Algorithm.refin.{0} Aeneas.Std.U128\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (@CrcBody.Digest.crc.{0, 0, 0} Aeneas.Std.U128\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U128\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcNoTable128.Crc128._proof_2))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 0) (instOfNatNat (nat_lit 0)))\n CrcNoTable128.Crc128._proof_1))\n self)))\n poly state\n (@List.map.{0, 0} Aeneas.Std.U8 (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 8) (instOfNatNat (nat_lit 8))))\n (@Aeneas.Std.UScalar.bv Aeneas.Std.UScalarTy.U8) (@Aeneas.Std.Slice.val.{0} Aeneas.Std.U8 bytes))))))","theorem":"CrcPartial128.digest_update_notable","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U32","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U32","text":"Aeneas.Std.U32"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑a.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 32","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"32"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"a.poly.bv = BitVec.setWidth 32 poly","type_segments":[{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U32.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"32"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc32.CrcU32Table.new 1#usize a = Aeneas.Std.Result.ok out ∧\n out.algorithm = a ∧ CrcPartial32.Coherent out poly","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc32.CrcU32Table.new","text":"CrcBody.crc32.CrcU32Table.new"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"},{"ref":"And","text":" ∧ "},{"ref":"CrcPartial32.Coherent","text":"CrcPartial32.Coherent"},{"text":" "},{"text":"out"},{"text":" "},{"text":"poly"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32","source":{"first_line":671,"last_line":671}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U32.bv","source":{"first_line":1109,"last_line":1109}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.Public32","name":"CrcPublic32.Crc32","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc32.CrcU32Table.new","source":{"first_line":2125,"last_line":2133}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.Public32","name":"CrcPublic32.Crc32._proof_1","source":null},{"module":"Stage2Proofs.Update32","name":"CrcUpdate32.Table","source":{"first_line":5,"last_line":5}},{"module":"Stage2Proofs.Partial32","name":"CrcPartial32.Coherent","source":{"first_line":9,"last_line":11}}],"definitions_truncated":false,"first_line":18,"last_line":66,"module":"Stage2Proofs.PartialConstructor32","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U32)\n (poly :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a)))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))))\n (Aeneas.Std.U32.bv (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U32 a))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 32) (instOfNatNat (nat_lit 32))) poly)),\n @Exists.{1} CrcPublic32.Crc32 fun (out : CrcPublic32.Crc32) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc32.CrcU32Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U32\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U32)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U32\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic32.Crc32._proof_1))\n CrcUpdate32.Table out)\n a)\n (@CrcPartial32.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U32 a))\n out poly))","theorem":"CrcPartialConstructor32.new_table1","translation_rerun":false,"version":1}
proofs.rs:formal:{"axioms":["propext","Classical.choice","Quot.sound"],"binders":[{"binder":"explicit","kind":"variable","name":"a","type":"CrcBody.crc_catalog.Algorithm Aeneas.Std.U64","type_segments":[{"ref":"CrcBody.crc_catalog.Algorithm","text":"CrcBody.crc_catalog.Algorithm"},{"text":" "},{"ref":"Aeneas.Std.U64","text":"Aeneas.Std.U64"}]},{"binder":"explicit","kind":"variable","name":"poly","type":"BitVec ↑a.width","type_segments":[{"ref":"BitVec","text":"BitVec"},{"text":" "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"}]},{"binder":"explicit","kind":"hypothesis","name":"hw","type":"1 ≤ ↑a.width ∧ ↑a.width ≤ 64","type_segments":[{"text":"1"},{"ref":"LE.le","text":" ≤ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"And","text":" ∧ "},{"text":"↑"},{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.width","text":"width"},{"ref":"LE.le","text":" ≤ "},{"text":"64"}]},{"binder":"explicit","kind":"hypothesis","name":"hp","type":"a.poly.bv = BitVec.setWidth 64 poly","type_segments":[{"text":"a"},{"text":"."},{"ref":"CrcBody.crc_catalog.Algorithm.poly","text":"poly"},{"text":"."},{"ref":"Aeneas.Std.U64.bv","text":"bv"},{"ref":"Eq","text":" = "},{"ref":"BitVec.setWidth","text":"BitVec.setWidth"},{"text":" "},{"text":"64"},{"text":" "},{"text":"poly"}]}],"conclusion":"∃ out,\n CrcBody.crc64.CrcU64Table.new 1#usize a = Aeneas.Std.Result.ok out ∧\n out.algorithm = a ∧ CrcPartial64.Coherent out poly","conclusion_segments":[{"text":"∃ "},{"text":"out"},{"text":",\n "},{"ref":"CrcBody.crc64.CrcU64Table.new","text":"CrcBody.crc64.CrcU64Table.new"},{"text":" "},{"text":"1"},{"ref":"Aeneas.Std.Usize.ofNat","text":"#usize"},{"text":" "},{"text":"a"},{"ref":"Eq","text":" = "},{"ref":"Aeneas.Std.Result.ok","text":"Aeneas.Std.Result.ok"},{"text":" "},{"text":"out"},{"ref":"And","text":" ∧\n "},{"text":"out"},{"text":"."},{"ref":"CrcBody.Crc.algorithm","text":"algorithm"},{"ref":"Eq","text":" = "},{"text":"a"},{"ref":"And","text":" ∧ "},{"ref":"CrcPartial64.Coherent","text":"CrcPartial64.Coherent"},{"text":" "},{"text":"out"},{"text":" "},{"text":"poly"}],"definitions":[{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm","source":{"first_line":23,"last_line":36}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64","source":{"first_line":672,"last_line":672}},{"module":"Init.Prelude","name":"BitVec","source":{"first_line":2496,"last_line":2508}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.val","source":{"first_line":76,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.U8","source":{"first_line":33,"last_line":33}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.width","source":{"first_line":29,"last_line":29}},{"module":"Init.Prelude","name":"And","source":{"first_line":645,"last_line":659}},{"module":"Init.Prelude","name":"LE.le","source":{"first_line":1402,"last_line":1402}},{"module":"Init.Prelude","name":"Nat","source":{"first_line":1349,"last_line":1371}},{"module":"Init.Prelude","name":"instLENat","source":{"first_line":2026,"last_line":2027}},{"module":"Init.Prelude","name":"OfNat.ofNat","source":{"first_line":1393,"last_line":1393}},{"module":"Init.Prelude","name":"instOfNatNat","source":{"first_line":1395,"last_line":1397}},{"module":"Init.Prelude","name":"Eq","source":{"first_line":46,"last_line":76}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.U64.bv","source":{"first_line":1110,"last_line":1110}},{"module":"CrcBody.Types","name":"CrcBody.crc_catalog.Algorithm.poly","source":{"first_line":30,"last_line":30}},{"module":"Init.Data.BitVec.Basic","name":"BitVec.setWidth","source":{"first_line":479,"last_line":498}},{"module":"Init.Core","name":"Exists","source":{"first_line":313,"last_line":341}},{"module":"Stage2Proofs.Public64","name":"CrcPublic64.Crc64","source":{"first_line":6,"last_line":6}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result","source":{"first_line":67,"last_line":68}},{"module":"CrcBody.Types","name":"CrcBody.Crc","source":{"first_line":38,"last_line":43}},{"module":"CrcBody.Types","name":"CrcBody.Table","source":{"first_line":45,"last_line":49}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.Usize.ofNat","source":{"first_line":703,"last_line":703}},{"module":"Init.Prelude","name":"of_decide_eq_true","source":{"first_line":1224,"last_line":1227}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalar.cMax","source":{"first_line":378,"last_line":381}},{"module":"Aeneas.Std.Scalar.Core","name":"Aeneas.Std.UScalarTy.Usize","source":{"first_line":32,"last_line":32}},{"module":"Init.Prelude","name":"Nat.decLe","source":{"first_line":2196,"last_line":2212}},{"module":"Init.Prelude","name":"id","source":{"first_line":119,"last_line":131}},{"module":"Init.Prelude","name":"Bool","source":{"first_line":99,"last_line":111}},{"module":"Init.Prelude","name":"Decidable.decide","source":{"first_line":1158,"last_line":1158}},{"module":"Init.Prelude","name":"Bool.true","source":{"first_line":110,"last_line":111}},{"module":"Init.Prelude","name":"Eq.refl","source":{"first_line":74,"last_line":76}},{"module":"Aeneas.Std.Array.Array","name":"Aeneas.Std.Array","source":{"first_line":28,"last_line":30}},{"module":"CrcBody.Funs","name":"CrcBody.table.crc128_table_loop0.body._proof_1","source":null},{"module":"CrcBody.Funs","name":"CrcBody.crc64.CrcU64Table.new","source":{"first_line":3057,"last_line":3065}},{"module":"Aeneas.Std.Primitives","name":"Aeneas.Std.Result.ok","source":{"first_line":72,"last_line":72}},{"module":"CrcBody.Types","name":"CrcBody.Crc.algorithm","source":{"first_line":42,"last_line":42}},{"module":"Stage2Proofs.Public64","name":"CrcPublic64.Crc64._proof_1","source":null},{"module":"Stage2Proofs.Update64","name":"CrcUpdate64.Table","source":{"first_line":5,"last_line":5}},{"module":"Stage2Proofs.Partial64","name":"CrcPartial64.Coherent","source":{"first_line":13,"last_line":14}}],"definitions_truncated":false,"first_line":18,"last_line":59,"module":"Stage2Proofs.PartialConstructor64","program":null,"program_head":null,"statement":"∀ (a : CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U64)\n (poly :\n BitVec\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a)))\n (hw :\n And\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a)))\n (@LE.le.{0} Nat instLENat\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64)))))\n (hp :\n @Eq.{1} (BitVec (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))))\n (Aeneas.Std.U64.bv (@CrcBody.crc_catalog.Algorithm.poly.{0} Aeneas.Std.U64 a))\n (@BitVec.setWidth\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a))\n (@OfNat.ofNat.{0} Nat (nat_lit 64) (instOfNatNat (nat_lit 64))) poly)),\n @Exists.{1} CrcPublic64.Crc64 fun (out : CrcPublic64.Crc64) =>\n And\n (@Eq.{1}\n (Aeneas.Std.Result.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))))\n (CrcBody.crc64.CrcU64Table.new\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))\n a)\n (@Aeneas.Std.Result.ok.{0}\n (CrcBody.Crc.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true)))))\n (Aeneas.Std.Array.{0}\n (Aeneas.Std.Array.{0} Aeneas.Std.U64\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 256) (instOfNatNat (nat_lit 256)))\n CrcBody.table.crc128_table_loop0.body._proof_1))\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (@of_decide_eq_true\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (@id.{0}\n (@Eq.{1} Bool\n (@Decidable.decide\n (@LE.le.{0} Nat instLENat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize))\n (Nat.decLe (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n (Aeneas.Std.UScalar.cMax Aeneas.Std.UScalarTy.Usize)))\n Bool.true)\n (@Eq.refl.{1} Bool Bool.true))))))\n out))\n (And\n (@Eq.{1} (CrcBody.crc_catalog.Algorithm.{0} Aeneas.Std.U64)\n (@CrcBody.Crc.algorithm.{0, 0, 0} Aeneas.Std.U64\n (CrcBody.Table\n (Aeneas.Std.Usize.ofNat (@OfNat.ofNat.{0} Nat (nat_lit 1) (instOfNatNat (nat_lit 1)))\n CrcPublic64.Crc64._proof_1))\n CrcUpdate64.Table out)\n a)\n (@CrcPartial64.Coherent\n (@Aeneas.Std.UScalar.val Aeneas.Std.UScalarTy.U8 (@CrcBody.crc_catalog.Algorithm.width.{0} Aeneas.Std.U64 a))\n out poly))","theorem":"CrcPartialConstructor64.new_table1","translation_rerun":false,"version":1}
=== stderr ===
info: aeneas: materializing new dependency
info: aeneas: fetching revision 'be86ab0f1989d04944292b345b24c435be3ad10a' from https://github.com/AeneasVerif/aeneas.git
info: aeneas: checking out revision 'be86ab0f1989d04944292b345b24c435be3ad10a'
info: mathlib: materializing new dependency
info: mathlib: fetching revision '56a005855ea17e0b0958f73ec801ae140b0a1679' from https://github.com/leanprover-community/mathlib4.git
info: mathlib: checking out revision '56a005855ea17e0b0958f73ec801ae140b0a1679'
info: plausible: materializing new dependency
info: plausible: fetching revision 'dfa4f38190d07c37e315953e08b90fe2d95b3c24' from https://github.com/leanprover-community/plausible
info: plausible: checking out revision 'dfa4f38190d07c37e315953e08b90fe2d95b3c24'
info: LeanSearchClient: materializing new dependency
info: LeanSearchClient: fetching revision 'd6b4c7be5be75ec4917c873ac50c756dc1436372' from https://github.com/leanprover-community/LeanSearchClient
info: LeanSearchClient: checking out revision 'd6b4c7be5be75ec4917c873ac50c756dc1436372'
info: importGraph: materializing new dependency
info: importGraph: fetching revision 'a41f0e9a4dea23188ea9cc1c41ac9f8bbafe0b93' from https://github.com/leanprover-community/import-graph
info: importGraph: checking out revision 'a41f0e9a4dea23188ea9cc1c41ac9f8bbafe0b93'
info: proofwidgets: materializing new dependency
info: proofwidgets: fetching revision 'df72b022e558978a1c50264cfc4d7fec86fa8e04' from https://github.com/leanprover-community/ProofWidgets4
info: proofwidgets: checking out revision 'df72b022e558978a1c50264cfc4d7fec86fa8e04'
info: aesop: materializing new dependency
info: aesop: fetching revision '4a174c490d8707121c4a9290800489f105d85e07' from https://github.com/leanprover-community/aesop
info: aesop: checking out revision '4a174c490d8707121c4a9290800489f105d85e07'
info: Qq: materializing new dependency
info: Qq: fetching revision 'dce0ad79c486cb1fb504af04f953c3466b0c6db8' from https://github.com/leanprover-community/quote4
info: Qq: checking out revision 'dce0ad79c486cb1fb504af04f953c3466b0c6db8'
info: batteries: materializing new dependency
info: batteries: fetching revision '66e469188fe07963e5cf666c7d4433f45b8131c5' from https://github.com/leanprover-community/batteries
info: batteries: checking out revision '66e469188fe07963e5cf666c7d4433f45b8131c5'
info: Cli: materializing new dependency
info: Cli: fetching revision 'c24fe6078c630e89b489bffe59b3e20ac30d12c8' from https://github.com/leanprover/lean4-cli
info: Cli: checking out revision 'c24fe6078c630e89b489bffe59b3e20ac30d12c8'