proofs.rs

Report #12 — crc 3.4.0: selected checksum and digest contracts

Aeneas be86ab0f1989d04944292b345b24c435be3ad10a

75 verified claims · 1 finding

Recorded by the author; proofs.rs has not re-run it. How to read a report

keiichiw · 2026-11-01 02:30 UTC

Revision v2 · v1

Overview

This profile proves conditional contracts for the built-in table implementations, or lanes: Table<0>, Table<1> and Table<16>.

Proved: Under the conditions below, selected checksum and update methods for Table<0> and Table<1> agree with a reference CRC register model. For all three lanes, selected digest initialization and finalization methods satisfy the contracts described below. The reference model is described in Trusted assumptions.

Not proved: The Table<16> checksum and update results for a message. Its initialization and finalization contracts cover the start and end of a digest, not the bytes processed between them.

Terms. Storage width is the bit size of the integer type (u8, u16, u32, u64 or u128). Below, width means Algorithm::width, the CRC width, which may be smaller. A canonical digest state encodes a register value that fits within width bits; the encoding depends on width and input reflection (refin).

Conditions for checksum and update: These claims are established under all applicable conditions below:

  • Parameters, both methods: 1 <= width <= storage width, and polynomial poly fits within width bits.
  • Final XOR, checksum: xorout fits within width bits.
  • Cache, Table<1>: the current cached table must match the current width, poly and refin. Reassigning the public Crc::algorithm field in safe Rust can break this coherence. Table<0> has no cached-table coherence requirement.
  • Incoming state, update: the digest state must encode a register value that fits within width bits.

The checksum init contract also depends on lane and storage type; the other applicable conditions above still apply:

Lane Storage type Checksum init: interpretation or condition
Table<0> All supported types The contract uses the low width bits; init need not fit within width bits.
Table<1> u32, u64 or u128 The contract uses the low width bits; init need not fit within width bits.
Table<1> u8 or u16 init must fit within width bits.

Each claim's details contain its authoritative formal statement, preconditions and theorem reference.

Checksum and update. Under these conditions, the selected methods succeed for every representable byte slice, including empty input; both reflection flags may vary independently. Checksum agrees with the reference model and update advances the encoded state by the reference model. In the Lean model of the translated code, the digest retains the same Crc object.

Digest and finalize. For all three lanes and valid widths (1 <= width <= storage width), digest_with_initial retains the Crc object in the Lean model and initializes from the low width bits of its argument; digest uses init. finalize succeeds for any raw digest word (the stored word before final processing), applying the specified word-level reflection, shift and XOR.

Constructors. Selected Table<0> constructors succeed and retain the algorithm under their recorded width conditions; selected Table<1> constructors also establish cache coherence under their recorded polynomial bounds.

Chunked updates. For both Table<0> and Table<1>, restricted to u8 storage with width = 8 and refin = false, additional proofs show that two successive selected updates equal an update of the concatenated input under the recorded premises. No all-width chunking theorem is claimed.

Coverage count. The coverage inventory lists 171 supported built-in callable instances:

  • Stage2 profile: 75 instances.
  • Default profile: 21 instances.
  • Together: 96 of the 171 instances.
  • Not formally covered by these profiles: the remaining 75 instances.

The inventory counts callable specializations across five storage widths and lanes 0, 1 and 16, including Clone::clone_from. It excludes re-exports, blanket methods and custom generic implementations. These are not distinct API names, and supporting lemmas are not additional API coverage. Native observations are separate from formal coverage. The accompanying finding records finite observations for Table<1> and Table<16>; those observations do not extend the proof coverage.

Findings (1)

APIs (75)

Recorded callables

Crc<u128, Table<0>>::checksum recorded callable · signature and safety not recorded
Claim #1
Crc<u128, Table<0>>::digest recorded callable · signature and safety not recorded
Claim #2
Crc<u128, Table<0>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #3
Crc<u128, Table<0>>::new recorded callable · signature and safety not recorded
Claim #4
Crc<u128, Table<16>>::digest recorded callable · signature and safety not recorded
Claim #5
Crc<u128, Table<16>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #6
Crc<u128, Table<1>>::checksum recorded callable · signature and safety not recorded
Claim #7
Crc<u128, Table<1>>::digest recorded callable · signature and safety not recorded
Claim #8
Crc<u128, Table<1>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #9
Crc<u128, Table<1>>::new recorded callable · signature and safety not recorded
Claim #10
Crc<u16, Table<0>>::checksum recorded callable · signature and safety not recorded
Claim #11
Crc<u16, Table<0>>::digest recorded callable · signature and safety not recorded
Claim #12
Crc<u16, Table<0>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #13
Crc<u16, Table<0>>::new recorded callable · signature and safety not recorded
Claim #14
Crc<u16, Table<16>>::digest recorded callable · signature and safety not recorded
Claim #15
Crc<u16, Table<16>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #16
Crc<u16, Table<1>>::checksum recorded callable · signature and safety not recorded
Claim #17
Crc<u16, Table<1>>::digest recorded callable · signature and safety not recorded
Claim #18
Crc<u16, Table<1>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #19
Crc<u16, Table<1>>::new recorded callable · signature and safety not recorded
Claim #20
Crc<u32, Table<0>>::checksum recorded callable · signature and safety not recorded
Claim #21
Crc<u32, Table<0>>::digest recorded callable · signature and safety not recorded
Claim #22
Crc<u32, Table<0>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #23
Crc<u32, Table<0>>::new recorded callable · signature and safety not recorded
Claim #24
Crc<u32, Table<16>>::digest recorded callable · signature and safety not recorded
Claim #25
Crc<u32, Table<16>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #26
Crc<u32, Table<1>>::checksum recorded callable · signature and safety not recorded
Claim #27
Crc<u32, Table<1>>::digest recorded callable · signature and safety not recorded
Claim #28
Crc<u32, Table<1>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #29
Crc<u32, Table<1>>::new recorded callable · signature and safety not recorded
Claim #30
Crc<u64, Table<0>>::checksum recorded callable · signature and safety not recorded
Claim #31
Crc<u64, Table<0>>::digest recorded callable · signature and safety not recorded
Claim #32
Crc<u64, Table<0>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #33
Crc<u64, Table<0>>::new recorded callable · signature and safety not recorded
Claim #34
Crc<u64, Table<16>>::digest recorded callable · signature and safety not recorded
Claim #35
Crc<u64, Table<16>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #36
Crc<u64, Table<1>>::checksum recorded callable · signature and safety not recorded
Claim #37
Crc<u64, Table<1>>::digest recorded callable · signature and safety not recorded
Claim #38
Crc<u64, Table<1>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #39
Crc<u64, Table<1>>::new recorded callable · signature and safety not recorded
Claim #40
Crc<u8, Table<0>>::checksum recorded callable · signature and safety not recorded
Claim #41
Crc<u8, Table<0>>::digest recorded callable · signature and safety not recorded
Claim #42
Crc<u8, Table<0>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #43
Crc<u8, Table<0>>::new recorded callable · signature and safety not recorded
Claim #44
Crc<u8, Table<16>>::digest recorded callable · signature and safety not recorded
Claim #45
Crc<u8, Table<16>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #46
Crc<u8, Table<1>>::checksum recorded callable · signature and safety not recorded
Claim #47
Crc<u8, Table<1>>::digest recorded callable · signature and safety not recorded
Claim #48
Crc<u8, Table<1>>::digest_with_initial recorded callable · signature and safety not recorded
Claim #49
Crc<u8, Table<1>>::new recorded callable · signature and safety not recorded
Claim #50
Digest<u128, Table<0>>::finalize recorded callable · signature and safety not recorded
Claim #51
Digest<u128, Table<0>>::update recorded callable · signature and safety not recorded
Claim #52
Digest<u128, Table<16>>::finalize recorded callable · signature and safety not recorded
Claim #53
Digest<u128, Table<1>>::finalize recorded callable · signature and safety not recorded
Claim #54
Digest<u128, Table<1>>::update recorded callable · signature and safety not recorded
Claim #55
Digest<u16, Table<0>>::finalize recorded callable · signature and safety not recorded
Claim #56
Digest<u16, Table<0>>::update recorded callable · signature and safety not recorded
Claim #57
Digest<u16, Table<16>>::finalize recorded callable · signature and safety not recorded
Claim #58
Digest<u16, Table<1>>::finalize recorded callable · signature and safety not recorded
Claim #59
Digest<u16, Table<1>>::update recorded callable · signature and safety not recorded
Claim #60
Digest<u32, Table<0>>::finalize recorded callable · signature and safety not recorded
Claim #61
Digest<u32, Table<0>>::update recorded callable · signature and safety not recorded
Claim #62
Digest<u32, Table<16>>::finalize recorded callable · signature and safety not recorded
Claim #63
Digest<u32, Table<1>>::finalize recorded callable · signature and safety not recorded
Claim #64
Digest<u32, Table<1>>::update recorded callable · signature and safety not recorded
Claim #65
Digest<u64, Table<0>>::finalize recorded callable · signature and safety not recorded
Claim #66
Digest<u64, Table<0>>::update recorded callable · signature and safety not recorded
Claim #67
Digest<u64, Table<16>>::finalize recorded callable · signature and safety not recorded
Claim #68
Digest<u64, Table<1>>::finalize recorded callable · signature and safety not recorded
Claim #69
Digest<u64, Table<1>>::update recorded callable · signature and safety not recorded
Claim #70
Digest<u8, Table<0>>::finalize recorded callable · signature and safety not recorded
Claim #71
Digest<u8, Table<0>>::update recorded callable · signature and safety not recorded
Claim #72
Digest<u8, Table<16>>::finalize recorded callable · signature and safety not recorded
Claim #73
Digest<u8, Table<1>>::finalize recorded callable · signature and safety not recorded
Claim #74
Digest<u8, Table<1>>::update recorded callable · signature and safety not recorded
Claim #75

Evidence

https://github.com/keiichiw/crate-proofs/tree/d0358890f8bdc8e72a376d225667ac162f89e3b8

Reproduce

Toolchain source metadata: not recorded.

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 --stdin

Checks out the recorded source commit from GitHub. Install the report’s tool version before running.

Source on GitHub · SARIF with logs (.json)

Recorded run

Completed · 75 checks passed · 0 failed

2026-10-31T04:53:01.903271+00:00 · 1123.4 seconds · Exit code 0

Recorded on the author’s machine.

CheckResultClaim
Lean checked theorem CrcPartialNoTableConstructors.checksum128; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.checksum128
PassedClaim #1
Lean checked theorem CrcPublicWordInstances.digest128_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest128_lane0_spec
PassedClaim #2
Lean checked theorem CrcPublicWordInstances.digest_with_initial128_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial128_lane0_spec
PassedClaim #3
Lean checked theorem CrcPartialNoTableConstructors.new_total128; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.new_total128
PassedClaim #4
Lean checked theorem CrcPublicWordInstances.digest128_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest128_lane16_spec
PassedClaim #5
Lean checked theorem CrcPublicWordInstances.digest_with_initial128_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial128_lane16_spec
PassedClaim #6
Lean checked theorem CrcPartial128.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial128.checksum_table1
PassedClaim #7
Lean checked theorem CrcPublicWordInstances.digest128_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest128_lane1_spec
PassedClaim #8
Lean checked theorem CrcPublicWordInstances.digest_with_initial128_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial128_lane1_spec
PassedClaim #9
Lean checked theorem CrcPartialConstructor128.new_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialConstructor128.new_table1
PassedClaim #10
Lean checked theorem CrcPartialNoTableConstructors.checksum16; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.checksum16
PassedClaim #11
Lean checked theorem CrcPublicWordInstances.digest16_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest16_lane0_spec
PassedClaim #12
Lean checked theorem CrcPublicWordInstances.digest_with_initial16_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial16_lane0_spec
PassedClaim #13
Lean checked theorem CrcPartialNoTableConstructors.new_total16; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.new_total16
PassedClaim #14
Lean checked theorem CrcPublicWordInstances.digest16_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest16_lane16_spec
PassedClaim #15
Lean checked theorem CrcPublicWordInstances.digest_with_initial16_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial16_lane16_spec
PassedClaim #16
Lean checked theorem CrcPartial16.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial16.checksum_table1
PassedClaim #17
Lean checked theorem CrcPublicWordInstances.digest16_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest16_lane1_spec
PassedClaim #18
Lean checked theorem CrcPublicWordInstances.digest_with_initial16_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial16_lane1_spec
PassedClaim #19
Lean checked theorem CrcPartialConstructor16.new_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialConstructor16.new_table1
PassedClaim #20
Lean checked theorem CrcPartialNoTableConstructors.checksum32; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.checksum32
PassedClaim #21
Lean checked theorem CrcPublicWordInstances.digest32_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest32_lane0_spec
PassedClaim #22
Lean checked theorem CrcPublicWordInstances.digest_with_initial32_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial32_lane0_spec
PassedClaim #23
Lean checked theorem CrcPartialNoTableConstructors.new_total32; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.new_total32
PassedClaim #24
Lean checked theorem CrcPublicWordInstances.digest32_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest32_lane16_spec
PassedClaim #25
Lean checked theorem CrcPublicWordInstances.digest_with_initial32_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial32_lane16_spec
PassedClaim #26
Lean checked theorem CrcPartial32.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial32.checksum_table1
PassedClaim #27
Lean checked theorem CrcPublicWordInstances.digest32_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest32_lane1_spec
PassedClaim #28
Lean checked theorem CrcPublicWordInstances.digest_with_initial32_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial32_lane1_spec
PassedClaim #29
Lean checked theorem CrcPartialConstructor32.new_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialConstructor32.new_table1
PassedClaim #30
Lean checked theorem CrcPartialNoTableConstructors.checksum64; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.checksum64
PassedClaim #31
Lean checked theorem CrcPublicWordInstances.digest64_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest64_lane0_spec
PassedClaim #32
Lean checked theorem CrcPublicWordInstances.digest_with_initial64_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial64_lane0_spec
PassedClaim #33
Lean checked theorem CrcPartialNoTableConstructors.new_total64; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.new_total64
PassedClaim #34
Lean checked theorem CrcPublicWordInstances.digest64_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest64_lane16_spec
PassedClaim #35
Lean checked theorem CrcPublicWordInstances.digest_with_initial64_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial64_lane16_spec
PassedClaim #36
Lean checked theorem CrcPartial64.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial64.checksum_table1
PassedClaim #37
Lean checked theorem CrcPublicWordInstances.digest64_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest64_lane1_spec
PassedClaim #38
Lean checked theorem CrcPublicWordInstances.digest_with_initial64_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial64_lane1_spec
PassedClaim #39
Lean checked theorem CrcPartialConstructor64.new_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialConstructor64.new_table1
PassedClaim #40
Lean checked theorem CrcPartialNoTableConstructors.checksum8; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.checksum8
PassedClaim #41
Lean checked theorem CrcPublicWordInstances.digest8_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest8_lane0_spec
PassedClaim #42
Lean checked theorem CrcPublicWordInstances.digest_with_initial8_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial8_lane0_spec
PassedClaim #43
Lean checked theorem CrcPartialNoTableConstructors.new_total8; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialNoTableConstructors.new_total8
PassedClaim #44
Lean checked theorem CrcPublicWordInstances.digest8_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest8_lane16_spec
PassedClaim #45
Lean checked theorem CrcPublicWordInstances.digest_with_initial8_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial8_lane16_spec
PassedClaim #46
Lean checked theorem CrcPartial8.checksum_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial8.checksum_table1
PassedClaim #47
Lean checked theorem CrcPublicWordInstances.digest8_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest8_lane1_spec
PassedClaim #48
Lean checked theorem CrcPublicWordInstances.digest_with_initial8_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_with_initial8_lane1_spec
PassedClaim #49
Lean checked theorem CrcPartialConstructor8.new_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartialConstructor8.new_table1
PassedClaim #50
Lean checked theorem CrcPublicWordInstances.digest_finalize128_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize128_lane0_spec
PassedClaim #51
Lean checked theorem CrcPartial128.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial128.digest_update_notable
PassedClaim #52
Lean checked theorem CrcPublicWordInstances.digest_finalize128_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize128_lane16_spec
PassedClaim #53
Lean checked theorem CrcPublicWordInstances.digest_finalize128_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize128_lane1_spec
PassedClaim #54
Lean checked theorem CrcPartial128.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial128.digest_update_table1
PassedClaim #55
Lean checked theorem CrcPublicWordInstances.digest_finalize16_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize16_lane0_spec
PassedClaim #56
Lean checked theorem CrcPartial16.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial16.digest_update_notable
PassedClaim #57
Lean checked theorem CrcPublicWordInstances.digest_finalize16_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize16_lane16_spec
PassedClaim #58
Lean checked theorem CrcPublicWordInstances.digest_finalize16_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize16_lane1_spec
PassedClaim #59
Lean checked theorem CrcPartial16.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial16.digest_update_table1
PassedClaim #60
Lean checked theorem CrcPublicWordInstances.digest_finalize32_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize32_lane0_spec
PassedClaim #61
Lean checked theorem CrcPartial32.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial32.digest_update_notable
PassedClaim #62
Lean checked theorem CrcPublicWordInstances.digest_finalize32_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize32_lane16_spec
PassedClaim #63
Lean checked theorem CrcPublicWordInstances.digest_finalize32_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize32_lane1_spec
PassedClaim #64
Lean checked theorem CrcPartial32.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial32.digest_update_table1
PassedClaim #65
Lean checked theorem CrcPublicWordInstances.digest_finalize64_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize64_lane0_spec
PassedClaim #66
Lean checked theorem CrcPartial64.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial64.digest_update_notable
PassedClaim #67
Lean checked theorem CrcPublicWordInstances.digest_finalize64_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize64_lane16_spec
PassedClaim #68
Lean checked theorem CrcPublicWordInstances.digest_finalize64_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize64_lane1_spec
PassedClaim #69
Lean checked theorem CrcPartial64.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial64.digest_update_table1
PassedClaim #70
Lean checked theorem CrcPublicWordInstances.digest_finalize8_lane0_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize8_lane0_spec
PassedClaim #71
Lean checked theorem CrcPartial8.digest_update_notable; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial8.digest_update_notable
PassedClaim #72
Lean checked theorem CrcPublicWordInstances.digest_finalize8_lane16_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize8_lane16_spec
PassedClaim #73
Lean checked theorem CrcPublicWordInstances.digest_finalize8_lane1_spec; axioms limited to propext, Classical.choice, Quot.sound
CrcPublicWordInstances.digest_finalize8_lane1_spec
PassedClaim #74
Lean checked theorem CrcPartial8.digest_update_table1; axioms limited to propext, Classical.choice, Quot.sound
CrcPartial8.digest_update_table1
PassedClaim #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'
Environment

This recording rechecked existing Lean proofs; it did not regenerate Lean from Rust. The standard Lean build and axiom audits passed. Theorem and evidence metadata was collected from the existing Lean proofs. Native tests and independent oracle examples are finite observations, separate from the formal proofs.

Reproduction details

The official CLI's opt-in concrete_api discovery checks that the configured callable functions exist for the selected build. It does not prove their behavior or translate Rust to Lean. For this check:

  • Declaration expansion selects the active configuration; RUSTC_BOOTSTRAP is scoped to that expansion.
  • Stable Rust function-item probes check the selected instances against the locked dependency graph and host configuration.

The recording covers 75 contracts, one per configured callable instance. Its configuration and identifiers are:

  • Target: macOS arm64 (aarch64-apple-darwin); Cargo default features, with no crate feature flags.
  • Source: locked release under upstream/, revision d035889.
  • Official unpatched CLI: revision 224bc10, including merged PR #93.
  • Run: 2981087e-e14c-442f-b9a6-b9b0139e90ae.

The 2026-10-23 run used an earlier configuration and is historical evidence for that configuration. See the historical results, theorem inventory, specification, and source lock.

What is trusted

The results depend on Rust-to-LLBC translation (LLBC is the intermediate representation consumed by Aeneas), Aeneas translation, primitive models, and the Lean kernel. Local bit-reversal definitions are assumed to match Rust's standard operations.

Reference model. The model feeds each byte in input-reflection order, applies output reflection and XOR at the end, and appends no zero block.

The proofs concern the translated program after three transformations used to normalize types and names and make source file references portable. If these transformations changed behavior, the proofs could describe a different program. Structural checks support their correspondence to the original translation, but do not formally prove it:

  • Type-only normalization lifts the built-in table associated type to the exact array type. An independent checker compares function bodies and permits only the specified type-reference changes; negative guards reject unsupported normalization shapes.
  • A display-name change preserves indices and operations.
  • File-name relocation is checked by inverse equality of the complete JSON tree.

These checks are not semantic-preservation or compiler-correctness proofs. The transitive audit permits only propext, Classical.choice, and Quot.sound.

Technical limitations

Conditions for users. Algorithm fields are public, so Rust types do not rule out invalid widths or out-of-range parameters. The public algorithm field of Crc can be replaced after construction, potentially leaving a stale cache. In addition to the parameter conditions, Table<1> checksum and update require the current table to be coherent with the current algorithm; construction alone does not establish coherence after a change. Table<0> has no cached-table coherence requirement.

Not covered. Table<16> checksum and update over message bytes, custom implementations, other lanes and re-exported dependency APIs are outside this coverage. The proofs do not validate catalogue check or residue values.

The selected executable crate bodies come from the locked crates.io 3.4.0 archive. The existing Rust-to-Lean translation (not rerun in this recording) uses the described transformations and locally authored bit-reversal models; their correspondence to release execution is supported by structural checks and native observations, not a formal equivalence theorem.

Tool limitations

Lean backend only, requiring cargo-proofs 0.4.0 or later. The version identifies the official Aeneas Git revision pinned in lake-manifest.json (backends/lean); this revision uses Lean 4.35.0. The recorder checks committed Lean theorem declarations and permits only propext, Classical.choice, and Quot.sound as transitive axioms. It rejects sorryAx and custom axioms, including axiomatized external models. Charon/Aeneas extraction is not rerun. The author must review that the committed functional model matches the recorded Rust source, that the named theorem corresponds to the public API, and that the reported precondition matches the theorem. A checked theorem alone does not establish those links or the adequacy of the specification. The current adapter records the default Cargo configuration, with ordinary Lean module paths and a pinned official Git dependency. Other backends, custom Lake source directories, and local-path Aeneas dependencies are unsupported. See https://proofs.rs/book/aeneas.html and https://github.com/AeneasVerif/aeneas/tree/be86ab0f1989d04944292b345b24c435be3ad10a.

Updated 2026-10-16 00:00 UTC

Aeneas be86ab0f1989d04944292b345b24c435be3ad10a — version details

Dependencies (1)

CrateReports
crc-catalog ^2.4.0—

Comments (0)

No comments.

Sign in to comment.