hax-lib 0.4.0

-- THIS FILE WAS AUTOMATICALLY GENERATED BY AENEAS
-- [core_models]: function definitions
import Aeneas
import CoreModels.Core.FunsPrologue
import CoreModels.Command
import CoreModels.Core.TypesPrologue
import CoreModels.Core.Types
import CoreModels.RustPrimitives.Funs
open CoreModels Aeneas
open Aeneas.Std hiding namespace core alloc
open RustM ControlFlow Error
open Std.Do
set_option linter.dupNamespace false
set_option linter.hashCommand false
set_option linter.unusedVariables false
set_option linter.style.whitespace false
set_option linter.style.setOption false
set_option linter.style.longLine false

/- You can set the `maxHeartbeats` value with the `-max-heartbeats` CLI option -/
set_option maxHeartbeats 1000000

/- You can set the `maxRecDepth` value with the `-max-recdepth` CLI option -/
set_option maxRecDepth 2048

namespace CoreModels.core

/-- [core_models::array::{core_models::array::Array<T, N>}::map]:
    Source: 'core-models/src/core/array.rs', lines 43:4-45:5
    Visibility: public -/
def array.Array.map
  {T : Type} {F : Type} {U : Type} {N : Std.Usize}
  (coreopsfunctionFnMutFTupleTUInst : core.ops.function.FnMut F T U)
  (s : Array T N) (f : F) :
  RustM (Array U N)
  := do
  rust_primitives.slice.array_map coreopsfunctionFnMutFTupleTUInst s f

/-- [core_models::array::{core_models::array::Array<T, N>}::as_slice]:
    Source: 'core-models/src/core/array.rs', lines 54:4-56:5
    Visibility: public -/
def array.Array.as_slice
  {T : Type} {N : Std.Usize} (s : Array T N) : RustM (Slice T) := do
  rust_primitives.slice.array_as_slice s

/-- [core_models::array::{core_models::array::Array<T, N>}::as_mut_slice]:
    Source: 'core-models/src/core/array.rs', lines 60:4-62:5
    Visibility: public -/
def array.Array.as_mut_slice
  {T : Type} {N : Std.Usize} (s : Array T N) :
  RustM ((Slice T) × (Slice T → Array T N))
  := do
  rust_primitives.slice.array_as_mut_slice s

/-- [core_models::array::{core_models::array::Array<T, N>}::each_ref::{impl core::ops::function::FnMut<(usize,), &'_ T> for core_models::array::{core_models::array::Array<T, N>}::each_ref::closure<'_0, T, N>}::call_mut]:
    Source: 'core-models/src/core/array.rs', lines 65:22-65:43 -/
def
  array.Array.each_ref.closure.Insts.CoreOpsFunctionFnMutTupleUsizeSharedT.call_mut
  {T : Type} {N : Std.Usize} (c : array.Array.each_ref.closure T N)
  (tupled_args : Std.Usize) :
  RustM (T × (array.Array.each_ref.closure T N))
  := do
  let t ← rust_primitives.slice.array_index c tupled_args
  ok (t, c)

/-- [core_models::array::{core_models::array::Array<T, N>}::each_ref::{impl core::ops::function::FnOnce<(usize,), &'_ T> for core_models::array::{core_models::array::Array<T, N>}::each_ref::closure<'_0, T, N>}::call_once]:
    Source: 'core-models/src/core/array.rs', lines 65:22-65:43 -/
def
  array.Array.each_ref.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeSharedT.call_once
  {T : Type} {N : Std.Usize} (c : array.Array.each_ref.closure T N)
  (i : Std.Usize) :
  RustM T
  := do
  let (t, _) ←
    array.Array.each_ref.closure.Insts.CoreOpsFunctionFnMutTupleUsizeSharedT.call_mut
      c i
  ok t

/-- Trait implementation: [core_models::array::{core_models::array::Array<T, N>}::each_ref::{impl core::ops::function::FnOnce<(usize,), &'_ T> for core_models::array::{core_models::array::Array<T, N>}::each_ref::closure<'_0, T, N>}]
    Source: 'core-models/src/core/array.rs', lines 65:22-65:43 -/
@[reducible]
def array.Array.each_ref.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeSharedT
  (T : Type) (N : Std.Usize) : core.ops.function.FnOnce
  (array.Array.each_ref.closure T N) Std.Usize T := {
  call_once :=
    array.Array.each_ref.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeSharedT.call_once
}

/-- Trait implementation: [core_models::array::{core_models::array::Array<T, N>}::each_ref::{impl core::ops::function::FnMut<(usize,), &'_ T> for core_models::array::{core_models::array::Array<T, N>}::each_ref::closure<'_0, T, N>}]
    Source: 'core-models/src/core/array.rs', lines 65:22-65:43 -/
@[reducible]
def array.Array.each_ref.closure.Insts.CoreOpsFunctionFnMutTupleUsizeSharedT (T
  : Type) (N : Std.Usize) : core.ops.function.FnMut
  (array.Array.each_ref.closure T N) Std.Usize T := {
  FnOnceInst :=
    array.Array.each_ref.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeSharedT T
    N
  call_mut :=
    array.Array.each_ref.closure.Insts.CoreOpsFunctionFnMutTupleUsizeSharedT.call_mut
}

/-- [core_models::array::{core_models::array::Array<T, N>}::each_ref]:
    Source: 'core-models/src/core/array.rs', lines 64:4-66:5
    Visibility: public -/
def array.Array.each_ref
  {T : Type} {N : Std.Usize} (s : Array T N) : RustM (Array T N) := do
  rust_primitives.slice.array_from_fn N
    (array.Array.each_ref.closure.Insts.CoreOpsFunctionFnMutTupleUsizeSharedT T
    N) s

/-- [core_models::array::from_fn]:
    Source: 'core-models/src/core/array.rs', lines 70:0-72:1
    Visibility: public -/
def array.from_fn
  {T : Type} {F : Type} (N : Std.Usize) (coreopsfunctionFnMutFTupleUsizeTInst :
  core.ops.function.FnMut F Std.Usize T) (f : F) :
  RustM (Array T N)
  := do
  rust_primitives.slice.array_from_fn N coreopsfunctionFnMutFTupleUsizeTInst f

/-- [core_models::array::iter::{impl core_models::iter::traits::iterator::Iterator<T> for core_models::array::iter::IntoIter<T, N>}::next]:
    Source: 'core-models/src/core/array.rs', lines 244:8-251:9
    Visibility: public -/
def array.iter.IntoIter.Insts.CoreIterTraitsIteratorIterator.next
  {T : Type} {N : Std.Usize} (self : array.iter.IntoIter T N) :
  RustM ((option.Option T) × (array.iter.IntoIter T N))
  := do
  let i ← rust_primitives.sequence.seq_len self
  if i = 0#usize
  then ok (option.Option.None, self)
  else
    let (res, s) ← rust_primitives.sequence.seq_remove self 0#usize
    ok (option.Option.Some res, s)

/-- Trait implementation: [core_models::array::iter::{impl core_models::iter::traits::iterator::Iterator<T> for core_models::array::iter::IntoIter<T, N>}]
    Source: 'core-models/src/core/array.rs', lines 242:4-252:5 -/
@[reducible]
def array.iter.IntoIter.Insts.CoreIterTraitsIteratorIterator (T : Type)
  (N : Std.Usize) : iter.traits.iterator.Iterator (array.iter.IntoIter T N) T
  := {
  next := array.iter.IntoIter.Insts.CoreIterTraitsIteratorIterator.next
}

/-- [core_models::array::{impl core_models::iter::traits::collect::IntoIterator<T, core_models::array::iter::IntoIter<T, N>> for [T; N]}::into_iter]:
    Source: 'core-models/src/core/array.rs', lines 78:4-80:5
    Visibility: public -/
def Array.Insts.CoreIterTraitsCollectIntoIteratorTIntoIter.into_iter
  {T : Type} {N : Std.Usize} (self : Array T N) :
  RustM (array.iter.IntoIter T N)
  := do
  let s ← rust_primitives.sequence.seq_from_array self
  ok s

/-- Trait implementation: [core_models::array::{impl core_models::iter::traits::collect::IntoIterator<T, core_models::array::iter::IntoIter<T, N>> for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 75:0-81:1 -/
@[reducible]
def Array.Insts.CoreIterTraitsCollectIntoIteratorTIntoIter (T : Type) (N
  : Std.Usize) : iter.traits.collect.IntoIterator (Array T N) T
  (array.iter.IntoIter T N) := {
  iteratorIteratorInst :=
    array.iter.IntoIter.Insts.CoreIterTraitsIteratorIterator T N
  into_iter :=
    Array.Insts.CoreIterTraitsCollectIntoIteratorTIntoIter.into_iter
}

/-- [core_models::array::{impl core_models::ops::index::Index<I, Clause0_Output> for [T; N]}::index]:
    Source: 'core-models/src/core/array.rs', lines 96:4-98:5
    Visibility: public -/
def Array.Insts.CoreOpsIndexIndex.index
  {T : Type} {I : Type} {Clause0_Output : Type} {N : Std.Usize}
  (opsindexIndexSliceIClause0_OutputInst : ops.index.Index (Slice T) I
  Clause0_Output) (self : Array T N) (i : I) :
  RustM Clause0_Output
  := do
  let s ← core.array.Array.as_slice self
  opsindexIndexSliceIClause0_OutputInst.index s i

/-- Trait implementation: [core_models::array::{impl core_models::ops::index::Index<I, Clause0_Output> for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 91:0-99:1 -/
@[reducible]
def Array.Insts.CoreOpsIndexIndex {T : Type} {I : Type} {Clause0_Output
  : Type} (N : Std.Usize) (opsindexIndexSliceIClause0_OutputInst :
  ops.index.Index (Slice T) I Clause0_Output) : ops.index.Index (Array T N) I
  Clause0_Output := {
  index := Array.Insts.CoreOpsIndexIndex.index
    opsindexIndexSliceIClause0_OutputInst
}

/-- [core_models::array::{impl core_models::ops::index::IndexMut<I, Clause0_Clause0_Output> for [T; N]}::index_mut]:
    Source: 'core-models/src/core/array.rs', lines 110:4-112:5
    Visibility: public -/
def Array.Insts.CoreOpsIndexIndexMut.index_mut
  {T : Type} {I : Type} {Clause0_Clause0_Output : Type} {N : Std.Usize}
  (opsindexIndexMutSliceIClause0_Clause0_OutputInst : ops.index.IndexMut (Slice
  T) I Clause0_Clause0_Output) (self : Array T N) (i : I) :
  RustM (Clause0_Clause0_Output × (Clause0_Clause0_Output → Array T N))
  := do
  let (s, as_mut_slice_back) ← array.Array.as_mut_slice self
  let (t, index_mut_back) ←
    opsindexIndexMutSliceIClause0_Clause0_OutputInst.index_mut s i
  let back := fun t1 => let s1 := index_mut_back t1
                        as_mut_slice_back s1
  ok (t, back)

/-- Trait implementation: [core_models::array::{impl core_models::ops::index::IndexMut<I, Clause0_Clause0_Output> for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 106:0-113:1 -/
@[reducible]
def Array.Insts.CoreOpsIndexIndexMut {T : Type} {I : Type}
  {Clause0_Clause0_Output : Type} (N : Std.Usize)
  (opsindexIndexMutSliceIClause0_Clause0_OutputInst : ops.index.IndexMut (Slice
  T) I Clause0_Clause0_Output) : ops.index.IndexMut (Array T N) I
  Clause0_Clause0_Output := {
  IndexInst := Array.Insts.CoreOpsIndexIndex N
    opsindexIndexMutSliceIClause0_Clause0_OutputInst.IndexInst
  index_mut := Array.Insts.CoreOpsIndexIndexMut.index_mut
    opsindexIndexMutSliceIClause0_Clause0_OutputInst
}

/-- [core_models::array::{impl core_models::clone::Clone for [T; N]}::clone_from]:
    Source: 'core-models/src/core/array.rs', lines 176:4-178:5
    Visibility: public -/
def Array.Insts.CoreCloneClone.clone_from
  {T : Type} {N : Std.Usize} (cloneCloneInst : clone.Clone T)
  (self : Array T N) (source : Array T N) :
  RustM (Array T N)
  := do
  ok source

/-- [core_models::array::{impl core_models::clone::Clone for [T; N]}::clone]:
    Source: 'core-models/src/core/array.rs', lines 169:4-171:5
    Visibility: public -/
def Array.Insts.CoreCloneClone.clone
  {T : Type} {N : Std.Usize} (cloneCloneInst : clone.Clone T)
  (self : Array T N) :
  RustM (Array T N)
  := do
  ok self

/-- Trait implementation: [core_models::array::{impl core_models::clone::Clone for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 168:0-179:1 -/
@[reducible]
def Array.Insts.CoreCloneClone {T : Type} (N : Std.Usize)
  (cloneCloneInst : clone.Clone T) : clone.Clone (Array T N) := {
  clone := Array.Insts.CoreCloneClone.clone cloneCloneInst
  clone_from := Array.Insts.CoreCloneClone.clone_from cloneCloneInst
}

/-- [core_models::array::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T; N]}::eq]: loop body 0:
    Source: 'core-models/src/core/array.rs', lines 192:12-199:9
    Visibility: public -/
@[rust_loop_body]
def Array.Insts.CoreCmpPartialEqArray.eq_loop.body
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Array T N) (other : Array U N) (i : Std.Usize) :
  RustM (ControlFlow Std.Usize Bool)
  := do
  if i < N
  then
    let t ← rust_primitives.slice.array_index self i
    let t1 ← rust_primitives.slice.array_index other i
    let b ← cmpPartialEqInst.eq t t1
    if b
    then let i1 ← i + 1#usize
         ok (cont i1)
    else ok (done false)
  else ok (done true)

/-- [core_models::array::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T; N]}::eq]: loop 0:
    Source: 'core-models/src/core/array.rs', lines 192:12-199:9
    Visibility: public -/
@[rust_loop]
def Array.Insts.CoreCmpPartialEqArray.eq_loop
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Array T N) (other : Array U N) (i : Std.Usize) :
  RustM Bool
  := do
  loop
    (fun i1 => Array.Insts.CoreCmpPartialEqArray.eq_loop.body
      cmpPartialEqInst self other i1)
    i

/-- [core_models::array::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T; N]}::eq]:
    Source: 'core-models/src/core/array.rs', lines 190:8-199:9
    Visibility: public -/
@[reducible]
def Array.Insts.CoreCmpPartialEqArray.eq
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Array T N) (other : Array U N) :
  RustM Bool
  := do
  Array.Insts.CoreCmpPartialEqArray.eq_loop cmpPartialEqInst self other
    0#usize

/-- [core_models::array::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T; N]}::ne]:
    Source: 'core-models/src/core/array.rs', lines 187:8-189:9
    Visibility: public -/
def Array.Insts.CoreCmpPartialEqArray.ne
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Array T N) (other : Array U N) :
  RustM Bool
  := do
  let b ←
    Array.Insts.CoreCmpPartialEqArray.eq cmpPartialEqInst self other
  ok (b = false)

/-- Trait implementation: [core_models::array::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 185:4-200:5 -/
@[reducible]
def Array.Insts.CoreCmpPartialEqArray {T : Type} {U : Type} (N :
  Std.Usize) (cmpPartialEqInst : cmp.PartialEq T U) : cmp.PartialEq (Array T N)
  (Array U N) := {
  eq := Array.Insts.CoreCmpPartialEqArray.eq cmpPartialEqInst
  ne := Array.Insts.CoreCmpPartialEqArray.ne cmpPartialEqInst
}

/-- [core_models::array::{impl core_models::default::Default for [T; N]}::default::{impl core::ops::function::FnMut<(usize,), T> for core_models::array::{impl core_models::default::Default for [T; N]}::default::closure<T, N>}::call_mut]:
    Source: 'core-models/src/core/array.rs', lines 210:22-210:68 -/
def
  array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT.call_mut
  {T : Type} {N : Std.Usize} (defaultDefaultInst : default.Default T)
  (c : array.DefaultArray.default.closure T N) (tupled_args : Std.Usize) :
  RustM (T × (array.DefaultArray.default.closure T N))
  := do
  let t ← defaultDefaultInst.default
  ok (t, c)

/-- [core_models::array::{impl core_models::default::Default for [T; N]}::default::{impl core::ops::function::FnOnce<(usize,), T> for core_models::array::{impl core_models::default::Default for [T; N]}::default::closure<T, N>}::call_once]:
    Source: 'core-models/src/core/array.rs', lines 210:22-210:68 -/
def
  array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT.call_once
  {T : Type} {N : Std.Usize} (defaultDefaultInst : default.Default T)
  (c : array.DefaultArray.default.closure T N) (i : Std.Usize) :
  RustM T
  := do
  let (t, _) ←
    array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT.call_mut
      defaultDefaultInst c i
  ok t

/-- Trait implementation: [core_models::array::{impl core_models::default::Default for [T; N]}::default::{impl core::ops::function::FnOnce<(usize,), T> for core_models::array::{impl core_models::default::Default for [T; N]}::default::closure<T, N>}]
    Source: 'core-models/src/core/array.rs', lines 210:22-210:68 -/
@[reducible]
def array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT
  {T : Type} (N : Std.Usize) (defaultDefaultInst : default.Default T) :
  core.ops.function.FnOnce (array.DefaultArray.default.closure T N) Std.Usize T
  := {
  call_once :=
    array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT.call_once
    defaultDefaultInst
}

/-- Trait implementation: [core_models::array::{impl core_models::default::Default for [T; N]}::default::{impl core::ops::function::FnMut<(usize,), T> for core_models::array::{impl core_models::default::Default for [T; N]}::default::closure<T, N>}]
    Source: 'core-models/src/core/array.rs', lines 210:22-210:68 -/
@[reducible]
def array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT {T
  : Type} (N : Std.Usize) (defaultDefaultInst : default.Default T) :
  core.ops.function.FnMut (array.DefaultArray.default.closure T N) Std.Usize T
  := {
  FnOnceInst :=
    array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT N
    defaultDefaultInst
  call_mut :=
    array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT.call_mut
    defaultDefaultInst
}

/-- [core_models::array::{impl core_models::default::Default for [T; N]}::default]:
    Source: 'core-models/src/core/array.rs', lines 209:4-211:5
    Visibility: public -/
def Array.Insts.CoreDefaultDefault.default
  {T : Type} (N : Std.Usize) (defaultDefaultInst : default.Default T) :
  RustM (Array T N)
  := do
  rust_primitives.slice.array_from_fn N
    (array.DefaultArray.default.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT N
    defaultDefaultInst) ()

/-- Trait implementation: [core_models::array::{impl core_models::default::Default for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 208:0-212:1 -/
@[reducible]
def Array.Insts.CoreDefaultDefault {T : Type} (N : Std.Usize)
  (defaultDefaultInst : default.Default T) : default.Default (Array T N) := {
  default := Array.Insts.CoreDefaultDefault.default N defaultDefaultInst
}

/-- [core_models::array::{impl core_models::fmt::Debug for [T; N]}::fmt]:
    Source: 'core-models/src/core/array.rs', lines 217:4-219:5
    Visibility: public -/
def Array.Insts.CoreFmtDebug.fmt
  {T : Type} {N : Std.Usize} (fmtDebugInst : fmt.Debug T) (self : Array T N)
  (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::array::{impl core_models::fmt::Debug for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 216:0-220:1 -/
@[reducible]
def Array.Insts.CoreFmtDebug {T : Type} (N : Std.Usize) (fmtDebugInst :
  fmt.Debug T) : fmt.Debug (Array T N) := {
  fmt := Array.Insts.CoreFmtDebug.fmt fmtDebugInst
}

/-- [core_models::array::{impl core_models::fmt::Debug for core_models::array::TryFromSliceError}::fmt]:
    Source: 'core-models/src/core/array.rs', lines 225:4-227:5
    Visibility: public -/
def array.TryFromSliceError.Insts.CoreFmtDebug.fmt
  (self : array.TryFromSliceError) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::array::{impl core_models::fmt::Debug for core_models::array::TryFromSliceError}]
    Source: 'core-models/src/core/array.rs', lines 224:0-228:1 -/
@[reducible]
def array.TryFromSliceError.Insts.CoreFmtDebug : fmt.Debug
  array.TryFromSliceError := {
  fmt := array.TryFromSliceError.Insts.CoreFmtDebug.fmt
}

/-- [core_models::array::{impl core_models::convert::AsRef<[T]> for [T; N]}::as_ref]:
    Source: 'core-models/src/core/array.rs', lines 232:4-234:5
    Visibility: public -/
def Array.Insts.CoreConvertAsRefSlice.as_ref
  {T : Type} {N : Std.Usize} (self : Array T N) : RustM (Slice T) := do
  rust_primitives.slice.array_as_slice self

/-- Trait implementation: [core_models::array::{impl core_models::convert::AsRef<[T]> for [T; N]}]
    Source: 'core-models/src/core/array.rs', lines 231:0-235:1 -/
@[reducible]
def Array.Insts.CoreConvertAsRefSlice (T : Type) (N : Std.Usize) :
  convert.AsRef (Array T N) (Slice T) := {
  as_ref := Array.Insts.CoreConvertAsRefSlice.as_ref
}

/-- [core_models::clone::Clone::clone_from]:
    Source: 'core-models/src/core/clone.rs', lines 19:4-24:5
    Visibility: public -/
@[trait_default]
def clone.Clone.clone_from.default
  {Self : Type} (CloneInst : clone.Clone Self) (self : Self) (source : Self) :
  RustM Self
  := do
  CloneInst.clone source

/-- [core_models::clone::{impl core_models::clone::Clone for bool}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def Bool.Insts.CoreCloneClone.clone (self : Bool) : RustM Bool := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for bool}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def Bool.Insts.CoreCloneClone : clone.Clone Bool := {
  clone := Bool.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default Bool.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for u8}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def U8.Insts.CoreCloneClone.clone (self : Std.U8) : RustM Std.U8 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for u8}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def U8.Insts.CoreCloneClone : clone.Clone Std.U8 := {
  clone := U8.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default U8.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for u16}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def U16.Insts.CoreCloneClone.clone
  (self : Std.U16) : RustM Std.U16 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for u16}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def U16.Insts.CoreCloneClone : clone.Clone Std.U16 := {
  clone := U16.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default U16.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for u32}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def U32.Insts.CoreCloneClone.clone
  (self : Std.U32) : RustM Std.U32 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for u32}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def U32.Insts.CoreCloneClone : clone.Clone Std.U32 := {
  clone := U32.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default U32.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for u64}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def U64.Insts.CoreCloneClone.clone
  (self : Std.U64) : RustM Std.U64 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for u64}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def U64.Insts.CoreCloneClone : clone.Clone Std.U64 := {
  clone := U64.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default U64.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for u128}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def U128.Insts.CoreCloneClone.clone
  (self : Std.U128) : RustM Std.U128 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for u128}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def U128.Insts.CoreCloneClone : clone.Clone Std.U128 := {
  clone := U128.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default U128.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for usize}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def Usize.Insts.CoreCloneClone.clone
  (self : Std.Usize) : RustM Std.Usize := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for usize}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def Usize.Insts.CoreCloneClone : clone.Clone Std.Usize := {
  clone := Usize.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default
    Usize.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for i8}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def I8.Insts.CoreCloneClone.clone (self : Std.I8) : RustM Std.I8 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for i8}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def I8.Insts.CoreCloneClone : clone.Clone Std.I8 := {
  clone := I8.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default I8.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for i16}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def I16.Insts.CoreCloneClone.clone
  (self : Std.I16) : RustM Std.I16 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for i16}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def I16.Insts.CoreCloneClone : clone.Clone Std.I16 := {
  clone := I16.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default I16.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for i32}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def I32.Insts.CoreCloneClone.clone
  (self : Std.I32) : RustM Std.I32 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for i32}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def I32.Insts.CoreCloneClone : clone.Clone Std.I32 := {
  clone := I32.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default I32.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for i64}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def I64.Insts.CoreCloneClone.clone
  (self : Std.I64) : RustM Std.I64 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for i64}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def I64.Insts.CoreCloneClone : clone.Clone Std.I64 := {
  clone := I64.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default I64.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for i128}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def I128.Insts.CoreCloneClone.clone
  (self : Std.I128) : RustM Std.I128 := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for i128}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def I128.Insts.CoreCloneClone : clone.Clone Std.I128 := {
  clone := I128.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default I128.Insts.CoreCloneClone
}

/-- [core_models::clone::{impl core_models::clone::Clone for isize}::clone]:
    Source: 'core-models/src/core/clone.rs', lines 39:16-41:17
    Visibility: public -/
def Isize.Insts.CoreCloneClone.clone
  (self : Std.Isize) : RustM Std.Isize := do
  ok self

/-- Trait implementation: [core_models::clone::{impl core_models::clone::Clone for isize}]
    Source: 'core-models/src/core/clone.rs', lines 38:12-42:13 -/
@[reducible]
impl_def Isize.Insts.CoreCloneClone : clone.Clone Std.Isize := {
  clone := Isize.Insts.CoreCloneClone.clone
  clone_from := clone.Clone.clone_from.default
    Isize.Insts.CoreCloneClone
}

/-- [core_models::cmp::PartialEq::ne]:
    Source: 'core-models/src/core/cmp.rs', lines 20:4-22:5
    Visibility: public -/
@[trait_default]
def cmp.PartialEq.ne.default
  {Self : Type} {Rhs : Type} (PartialEqInst : cmp.PartialEq Self Rhs)
  (self : Self) (other : Rhs) :
  RustM Bool
  := do
  let b ← PartialEqInst.eq self other
  ok (b = false)

/-- [core_models::cmp::PartialOrd::lt]:
    Source: 'core-models/src/core/cmp.rs', lines 53:4-55:5
    Visibility: public -/
@[trait_default]
def cmp.PartialOrd.lt.default
  {Self : Type} {Rhs : Type} (PartialOrdInst : cmp.PartialOrd Self Rhs)
  (self : Self) (other : Rhs) :
  RustM Bool
  := do
  let o ← PartialOrdInst.partial_cmp self other
  match o with
  | option.Option.Some o1 =>
    match o1 with
    | cmp.Ordering.Less => ok true
    | cmp.Ordering.Equal => ok false
    | cmp.Ordering.Greater => ok false
  | option.Option.None => ok false

/-- [core_models::cmp::PartialOrd::le]:
    Source: 'core-models/src/core/cmp.rs', lines 58:4-63:5
    Visibility: public -/
@[trait_default]
def cmp.PartialOrd.le.default
  {Self : Type} {Rhs : Type} (PartialOrdInst : cmp.PartialOrd Self Rhs)
  (self : Self) (other : Rhs) :
  RustM Bool
  := do
  let o ← PartialOrdInst.partial_cmp self other
  match o with
  | option.Option.Some o1 =>
    match o1 with
    | cmp.Ordering.Less => ok true
    | cmp.Ordering.Equal => ok true
    | cmp.Ordering.Greater => ok false
  | option.Option.None => ok false

/-- [core_models::cmp::PartialOrd::gt]:
    Source: 'core-models/src/core/cmp.rs', lines 66:4-68:5
    Visibility: public -/
@[trait_default]
def cmp.PartialOrd.gt.default
  {Self : Type} {Rhs : Type} (PartialOrdInst : cmp.PartialOrd Self Rhs)
  (self : Self) (other : Rhs) :
  RustM Bool
  := do
  let o ← PartialOrdInst.partial_cmp self other
  match o with
  | option.Option.Some o1 =>
    match o1 with
    | cmp.Ordering.Less => ok false
    | cmp.Ordering.Equal => ok false
    | cmp.Ordering.Greater => ok true
  | option.Option.None => ok false

/-- [core_models::cmp::PartialOrd::ge]:
    Source: 'core-models/src/core/cmp.rs', lines 71:4-76:5
    Visibility: public -/
@[trait_default]
def cmp.PartialOrd.ge.default
  {Self : Type} {Rhs : Type} (PartialOrdInst : cmp.PartialOrd Self Rhs)
  (self : Self) (other : Rhs) :
  RustM Bool
  := do
  let o ← PartialOrdInst.partial_cmp self other
  match o with
  | option.Option.Some o1 =>
    match o1 with
    | cmp.Ordering.Less => ok false
    | cmp.Ordering.Equal => ok true
    | cmp.Ordering.Greater => ok true
  | option.Option.None => ok false

/-- [core_models::cmp::{impl core_models::cmp::Neq<T> for T}::neq]:
    Source: 'core-models/src/core/cmp.rs', lines 86:4-89:5 -/
def cmp.Neq.Blanket.neq
  {T : Type} (PartialEqInst : cmp.PartialEq T T) (self : T) (y : T) :
  RustM Bool
  := do
  let b ← PartialEqInst.eq self y
  ok (b = false)

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::Neq<T> for T}]
    Source: 'core-models/src/core/cmp.rs', lines 85:0-90:1 -/
@[reducible]
def cmp.Neq.Blanket {T : Type} (PartialEqInst : cmp.PartialEq T T) : cmp.Neq T
  T := {
  neq := cmp.Neq.Blanket.neq PartialEqInst
}

/-- [core_models::cmp::max]:
    Source: 'core-models/src/core/cmp.rs', lines 158:0-163:1
    Visibility: public -/
def cmp.max {T : Type} (OrdInst : cmp.Ord T) (v1 : T) (v2 : T) : RustM T := do
  let o ← OrdInst.cmp v1 v2
  match o with
  | cmp.Ordering.Less => ok v2
  | cmp.Ordering.Equal => ok v2
  | cmp.Ordering.Greater => ok v1

/-- [core_models::cmp::min]:
    Source: 'core-models/src/core/cmp.rs', lines 166:0-171:1
    Visibility: public -/
def cmp.min {T : Type} (OrdInst : cmp.Ord T) (v1 : T) (v2 : T) : RustM T := do
  let o ← OrdInst.cmp v1 v2
  match o with
  | cmp.Ordering.Less => ok v1
  | cmp.Ordering.Equal => ok v1
  | cmp.Ordering.Greater => ok v2

/-- [core_models::cmp::{impl core_models::cmp::PartialEq<core_models::cmp::Reverse<T>> for core_models::cmp::Reverse<T>}::eq]:
    Source: 'core-models/src/core/cmp.rs', lines 187:4-189:5
    Visibility: public -/
def cmp.Reverse.Insts.CoreCmpPartialEqReverse.eq
  {T : Type} (PartialEqInst : cmp.PartialEq T T) (self : cmp.Reverse T)
  (other : cmp.Reverse T) :
  RustM Bool
  := do
  PartialEqInst.eq other self

/-- [core_models::cmp::{impl core_models::cmp::PartialEq<core_models::cmp::Reverse<T>> for core_models::cmp::Reverse<T>}::ne]:
    Source: 'core-models/src/core/cmp.rs', lines 184:4-186:5
    Visibility: public -/
def cmp.Reverse.Insts.CoreCmpPartialEqReverse.ne
  {T : Type} (PartialEqInst : cmp.PartialEq T T) (self : cmp.Reverse T)
  (other : cmp.Reverse T) :
  RustM Bool
  := do
  let b ←
    cmp.Reverse.Insts.CoreCmpPartialEqReverse.eq PartialEqInst self
      other
  ok (b = false)

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::PartialEq<core_models::cmp::Reverse<T>> for core_models::cmp::Reverse<T>}]
    Source: 'core-models/src/core/cmp.rs', lines 182:0-190:1 -/
@[reducible]
def cmp.Reverse.Insts.CoreCmpPartialEqReverse {T : Type} (PartialEqInst
  : cmp.PartialEq T T) : cmp.PartialEq (cmp.Reverse T) (cmp.Reverse T) := {
  eq := cmp.Reverse.Insts.CoreCmpPartialEqReverse.eq PartialEqInst
  ne := cmp.Reverse.Insts.CoreCmpPartialEqReverse.ne PartialEqInst
}

/-- [core_models::cmp::{impl core_models::cmp::PartialOrd<core_models::cmp::Reverse<T>> for core_models::cmp::Reverse<T>}::partial_cmp]:
    Source: 'core-models/src/core/cmp.rs', lines 177:4-179:5
    Visibility: public -/
def cmp.Reverse.Insts.CoreCmpPartialOrdReverse.partial_cmp
  {T : Type} (PartialOrdInst : cmp.PartialOrd T T) (self : cmp.Reverse T)
  (other : cmp.Reverse T) :
  RustM (option.Option cmp.Ordering)
  := do
  PartialOrdInst.partial_cmp other self

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::PartialOrd<core_models::cmp::Reverse<T>> for core_models::cmp::Reverse<T>}]
    Source: 'core-models/src/core/cmp.rs', lines 176:0-180:1 -/
@[reducible]
impl_def cmp.Reverse.Insts.CoreCmpPartialOrdReverse {T : Type}
  (PartialOrdInst : cmp.PartialOrd T T) : cmp.PartialOrd (cmp.Reverse T)
  (cmp.Reverse T) := {
  PartialEqInst := cmp.Reverse.Insts.CoreCmpPartialEqReverse
    PartialOrdInst.PartialEqInst
  partial_cmp := cmp.Reverse.Insts.CoreCmpPartialOrdReverse.partial_cmp
    PartialOrdInst
  lt := cmp.PartialOrd.lt.default
    (cmp.Reverse.Insts.CoreCmpPartialOrdReverse PartialOrdInst)
  le := cmp.PartialOrd.le.default
    (cmp.Reverse.Insts.CoreCmpPartialOrdReverse PartialOrdInst)
  gt := cmp.PartialOrd.gt.default
    (cmp.Reverse.Insts.CoreCmpPartialOrdReverse PartialOrdInst)
  ge := cmp.PartialOrd.ge.default
    (cmp.Reverse.Insts.CoreCmpPartialOrdReverse PartialOrdInst)
}

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::Eq for core_models::cmp::Reverse<T>}]
    Source: 'core-models/src/core/cmp.rs', lines 192:0-192:32 -/
@[reducible]
def cmp.Reverse.Insts.CoreCmpEq {T : Type} (EqInst : cmp.Eq T) : cmp.Eq
  (cmp.Reverse T) := {
  PartialEqInst := cmp.Reverse.Insts.CoreCmpPartialEqReverse
    EqInst.PartialEqInst
}

/-- [core_models::cmp::{impl core_models::cmp::Ord for core_models::cmp::Reverse<T>}::cmp]:
    Source: 'core-models/src/core/cmp.rs', lines 195:4-197:5
    Visibility: public -/
def cmp.Reverse.Insts.CoreCmpOrd.cmp
  {T : Type} (OrdInst : cmp.Ord T) (self : cmp.Reverse T)
  (other : cmp.Reverse T) :
  RustM cmp.Ordering
  := do
  OrdInst.cmp other self

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::Ord for core_models::cmp::Reverse<T>}]
    Source: 'core-models/src/core/cmp.rs', lines 194:0-198:1 -/
@[reducible]
def cmp.Reverse.Insts.CoreCmpOrd {T : Type} (OrdInst : cmp.Ord T) :
  cmp.Ord (cmp.Reverse T) := {
  EqInst := cmp.Reverse.Insts.CoreCmpEq OrdInst.EqInst
  PartialOrdInst := cmp.Reverse.Insts.CoreCmpPartialOrdReverse
    OrdInst.PartialOrdInst
  cmp := cmp.Reverse.Insts.CoreCmpOrd.cmp OrdInst
}

/-- [core_models::cmp::{core_models::cmp::Ordering}::is_eq]:
    Source: 'core-models/src/core/cmp.rs', lines 255:4-257:5
    Visibility: public -/
def cmp.Ordering.is_eq (self : cmp.Ordering) : RustM Bool := do
  match self with
  | cmp.Ordering.Less => ok false
  | cmp.Ordering.Equal => ok true
  | cmp.Ordering.Greater => ok false

/-- [core_models::cmp::{core_models::cmp::Ordering}::is_ne]:
    Source: 'core-models/src/core/cmp.rs', lines 259:4-261:5
    Visibility: public -/
def cmp.Ordering.is_ne (self : cmp.Ordering) : RustM Bool := do
  match self with
  | cmp.Ordering.Less => ok true
  | cmp.Ordering.Equal => ok false
  | cmp.Ordering.Greater => ok true

/-- [core_models::cmp::{core_models::cmp::Ordering}::is_lt]:
    Source: 'core-models/src/core/cmp.rs', lines 263:4-265:5
    Visibility: public -/
def cmp.Ordering.is_lt (self : cmp.Ordering) : RustM Bool := do
  match self with
  | cmp.Ordering.Less => ok true
  | cmp.Ordering.Equal => ok false
  | cmp.Ordering.Greater => ok false

/-- [core_models::cmp::{core_models::cmp::Ordering}::is_gt]:
    Source: 'core-models/src/core/cmp.rs', lines 267:4-269:5
    Visibility: public -/
def cmp.Ordering.is_gt (self : cmp.Ordering) : RustM Bool := do
  match self with
  | cmp.Ordering.Less => ok false
  | cmp.Ordering.Equal => ok false
  | cmp.Ordering.Greater => ok true

/-- [core_models::cmp::{core_models::cmp::Ordering}::is_le]:
    Source: 'core-models/src/core/cmp.rs', lines 271:4-273:5
    Visibility: public -/
def cmp.Ordering.is_le (self : cmp.Ordering) : RustM Bool := do
  match self with
  | cmp.Ordering.Less => ok true
  | cmp.Ordering.Equal => ok true
  | cmp.Ordering.Greater => ok false

/-- [core_models::cmp::{core_models::cmp::Ordering}::is_ge]:
    Source: 'core-models/src/core/cmp.rs', lines 275:4-277:5
    Visibility: public -/
def cmp.Ordering.is_ge (self : cmp.Ordering) : RustM Bool := do
  match self with
  | cmp.Ordering.Less => ok false
  | cmp.Ordering.Equal => ok true
  | cmp.Ordering.Greater => ok true

/-- [core_models::cmp::{core_models::cmp::Ordering}::reverse]:
    Source: 'core-models/src/core/cmp.rs', lines 279:4-285:5
    Visibility: public -/
def cmp.Ordering.reverse (self : cmp.Ordering) : RustM cmp.Ordering := do
  match self with
  | cmp.Ordering.Less => ok cmp.Ordering.Greater
  | cmp.Ordering.Equal => ok cmp.Ordering.Equal
  | cmp.Ordering.Greater => ok cmp.Ordering.Less

/-- [core_models::cmp::{core_models::cmp::Ordering}::then]:
    Source: 'core-models/src/core/cmp.rs', lines 287:4-292:5
    Visibility: public -/
def cmp.Ordering.then
  (self : cmp.Ordering) (other : cmp.Ordering) : RustM cmp.Ordering := do
  match self with
  | cmp.Ordering.Less => ok cmp.Ordering.Less
  | cmp.Ordering.Equal => ok other
  | cmp.Ordering.Greater => ok cmp.Ordering.Greater

/-- [core_models::cmp::{core_models::cmp::Ordering}::then_with]:
    Source: 'core-models/src/core/cmp.rs', lines 294:4-299:5
    Visibility: public -/
def cmp.Ordering.then_with
  {F : Type} (coreopsfunctionFnOnceFTupleOrderingInst :
  core.ops.function.FnOnce F Unit cmp.Ordering) (self : cmp.Ordering) 
  (f : F) :
  RustM cmp.Ordering
  := do
  match self with
  | cmp.Ordering.Less => ok cmp.Ordering.Less
  | cmp.Ordering.Equal =>
    coreopsfunctionFnOnceFTupleOrderingInst.call_once f ()
  | cmp.Ordering.Greater => ok cmp.Ordering.Greater

/-- [core_models::panicking::internal::panic]:
    Source: 'core-models/src/core/panicking.rs', lines 38:4-40:5
    Visibility: public -/
def panicking.internal.panic (T : Type) : RustM T := do
  fail Error.panic

/-- [core_models::cmp::clamp]:
    Source: 'core-models/src/core/cmp.rs', lines 304:0-316:1
    Visibility: public -/
def cmp.clamp
  {T : Type} (OrdInst : cmp.Ord T) (value : T) (min : T) (max : T) :
  RustM T
  := do
  let o ← OrdInst.cmp min max
  let b ← cmp.Ordering.is_le o
  if b
  then ok ()
  else panicking.internal.panic Unit
  let o1 ← OrdInst.cmp value min
  match o1 with
  | cmp.Ordering.Less => ok min
  | cmp.Ordering.Equal => ok value
  | cmp.Ordering.Greater =>
    let o2 ← OrdInst.cmp value max
    match o2 with
    | cmp.Ordering.Less => ok value
    | cmp.Ordering.Equal => ok value
    | cmp.Ordering.Greater => ok max

/-- [core_models::cmp::{impl core_models::cmp::PartialEq<()> for ()}::ne]:
    Source: 'core-models/src/core/cmp.rs', lines 327:4-329:5
    Visibility: public -/
def Tuple.Insts.CoreCmpPartialEqTuple.ne
  (_ : Unit) (_ : Unit) : RustM Bool := do
  ok false

/-- [core_models::cmp::{impl core_models::cmp::PartialEq<()> for ()}::eq]:
    Source: 'core-models/src/core/cmp.rs', lines 323:4-325:5
    Visibility: public -/
def Tuple.Insts.CoreCmpPartialEqTuple.eq
  (_ : Unit) (_ : Unit) : RustM Bool := do
  ok true

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::PartialEq<()> for ()}]
    Source: 'core-models/src/core/cmp.rs', lines 322:0-330:1 -/
@[reducible]
def Tuple.Insts.CoreCmpPartialEqTuple : cmp.PartialEq Unit Unit := {
  eq := Tuple.Insts.CoreCmpPartialEqTuple.eq
  ne := Tuple.Insts.CoreCmpPartialEqTuple.ne
}

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::Eq for ()}]
    Source: 'core-models/src/core/cmp.rs', lines 333:0-333:17 -/
@[reducible]
def Tuple.Insts.CoreCmpEq : cmp.Eq Unit := {
  PartialEqInst := Tuple.Insts.CoreCmpPartialEqTuple
}

/-- [core_models::cmp::{impl core_models::cmp::PartialOrd<()> for ()}::partial_cmp]:
    Source: 'core-models/src/core/cmp.rs', lines 337:4-339:5
    Visibility: public -/
def Tuple.Insts.CoreCmpPartialOrdTuple.partial_cmp
  (_ : Unit) (_ : Unit) : RustM (option.Option cmp.Ordering) := do
  ok (option.Option.Some cmp.Ordering.Equal)

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::PartialOrd<()> for ()}]
    Source: 'core-models/src/core/cmp.rs', lines 336:0-340:1 -/
@[reducible]
impl_def Tuple.Insts.CoreCmpPartialOrdTuple : cmp.PartialOrd Unit Unit
  := {
  PartialEqInst := Tuple.Insts.CoreCmpPartialEqTuple
  partial_cmp := Tuple.Insts.CoreCmpPartialOrdTuple.partial_cmp
  lt := cmp.PartialOrd.lt.default Tuple.Insts.CoreCmpPartialOrdTuple
  le := cmp.PartialOrd.le.default Tuple.Insts.CoreCmpPartialOrdTuple
  gt := cmp.PartialOrd.gt.default Tuple.Insts.CoreCmpPartialOrdTuple
  ge := cmp.PartialOrd.ge.default Tuple.Insts.CoreCmpPartialOrdTuple
}

/-- [core_models::cmp::{impl core_models::cmp::Ord for ()}::cmp]:
    Source: 'core-models/src/core/cmp.rs', lines 344:4-346:5
    Visibility: public -/
def Tuple.Insts.CoreCmpOrd.cmp
  (_ : Unit) (_ : Unit) : RustM cmp.Ordering := do
  ok cmp.Ordering.Equal

/-- Trait implementation: [core_models::cmp::{impl core_models::cmp::Ord for ()}]
    Source: 'core-models/src/core/cmp.rs', lines 343:0-347:1 -/
@[reducible]
def Tuple.Insts.CoreCmpOrd : cmp.Ord Unit := {
  EqInst := Tuple.Insts.CoreCmpEq
  PartialOrdInst := Tuple.Insts.CoreCmpPartialOrdTuple
  cmp := Tuple.Insts.CoreCmpOrd.cmp
}

/-- [core_models::convert::{impl core_models::convert::Into<U> for T}::into]:
    Source: 'core-models/src/core/convert.rs', lines 38:4-40:5 -/
def convert.Into.Blanket.into
  {T : Type} {U : Type} (FromInst : convert.From U T) (self : T) :
  RustM U
  := do
  FromInst.«from» self

/-- Trait implementation: [core_models::convert::{impl core_models::convert::Into<U> for T}]
    Source: 'core-models/src/core/convert.rs', lines 37:0-41:1 -/
@[reducible]
def convert.Into.Blanket {T : Type} {U : Type} (FromInst : convert.From U T) :
  convert.Into T U := {
  into := convert.Into.Blanket.into FromInst
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<T, core_models::convert::Infallible> for U}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 48:4-50:5
    Visibility: public -/
def convert.TryFromUTInfallible.Blanket.try_from
  {T : Type} {U : Type} (FromInst : convert.From U T) (x : T) :
  RustM (result.Result U convert.Infallible)
  := do
  let t ← FromInst.«from» x
  ok (result.Result.Ok t)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<T, core_models::convert::Infallible> for U}]
    Source: 'core-models/src/core/convert.rs', lines 46:0-51:1 -/
@[reducible]
def convert.TryFromUTInfallible.Blanket {T : Type} {U : Type} (FromInst :
  convert.From U T) : convert.TryFrom U T convert.Infallible := {
  try_from := convert.TryFromUTInfallible.Blanket.try_from FromInst
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::{impl core::ops::function::FnMut<(usize,), T> for core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::closure<'_0, '_1, T, N>}::call_mut]:
    Source: 'core-models/src/core/convert.rs', lines 59:61-61:13 -/
def
  convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT.call_mut
  {T : Type} {N : Std.Usize} (coremarkerCopyInst : core.marker.Copy T)
  (c : convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure T N)
  (tupled_args : Std.Usize) :
  RustM (T ×
    (convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure T N))
  := do
  let t ← rust_primitives.slice.slice_index c tupled_args
  ok (t, c)

/-- [core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::{impl core::ops::function::FnOnce<(usize,), T> for core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::closure<'_0, '_1, T, N>}::call_once]:
    Source: 'core-models/src/core/convert.rs', lines 59:61-61:13 -/
def
  convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT.call_once
  {T : Type} {N : Std.Usize} (coremarkerCopyInst : core.marker.Copy T)
  (c : convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure T N)
  (i : Std.Usize) :
  RustM T
  := do
  let (t, _) ←
    convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT.call_mut
      coremarkerCopyInst c i
  ok t

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::{impl core::ops::function::FnOnce<(usize,), T> for core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::closure<'_0, '_1, T, N>}]
    Source: 'core-models/src/core/convert.rs', lines 59:61-61:13 -/
@[reducible]
def
  convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT
  {T : Type} (N : Std.Usize) (coremarkerCopyInst : core.marker.Copy T) :
  core.ops.function.FnOnce
  (convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure T N)
  Std.Usize T := {
  call_once :=
    convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT.call_once
    coremarkerCopyInst
}

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::{impl core::ops::function::FnMut<(usize,), T> for core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from::closure<'_0, '_1, T, N>}]
    Source: 'core-models/src/core/convert.rs', lines 59:61-61:13 -/
@[reducible]
def
  convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT
  {T : Type} (N : Std.Usize) (coremarkerCopyInst : core.marker.Copy T) :
  core.ops.function.FnMut
  (convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure T N)
  Std.Usize T := {
  FnOnceInst :=
    convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnOnceTupleUsizeT
    N coremarkerCopyInst
  call_mut :=
    convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT.call_mut
    coremarkerCopyInst
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 57:4-65:5
    Visibility: public -/
def Array.Insts.CoreConvertTryFromShared0SliceTryFromSliceError.try_from
  {T : Type} (N : Std.Usize) (coremarkerCopyInst : core.marker.Copy T)
  (x : Slice T) :
  RustM (result.Result (Array T N) array.TryFromSliceError)
  := do
  let i ← rust_primitives.slice.slice_length x
  if i = N
  then
    let a ←
      rust_primitives.slice.array_from_fn N
        (convert.TryFromArrayShared0SliceTryFromSliceError.try_from.closure.Insts.CoreOpsFunctionFnMutTupleUsizeT
        N coremarkerCopyInst) x
    ok (result.Result.Ok a)
  else ok (result.Result.Err ())

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<&'_0 [T], core_models::array::TryFromSliceError> for [T; N]}]
    Source: 'core-models/src/core/convert.rs', lines 55:0-66:1 -/
@[reducible]
def Array.Insts.CoreConvertTryFromShared0SliceTryFromSliceError {T :
  Type} (N : Std.Usize) (coremarkerCopyInst : core.marker.Copy T) :
  convert.TryFrom (Array T N) (Slice T) array.TryFromSliceError := {
  try_from :=
    Array.Insts.CoreConvertTryFromShared0SliceTryFromSliceError.try_from
    N coremarkerCopyInst
}

/-- [core_models::convert::{impl core_models::convert::TryInto<U, Clause0_Error> for T}::try_into]:
    Source: 'core-models/src/core/convert.rs', lines 70:4-72:5 -/
def convert.TryInto.Blanket.try_into
  {T : Type} {U : Type} {Clause0_Error : Type} (TryFromInst : convert.TryFrom U
  T Clause0_Error) (self : T) :
  RustM (result.Result U Clause0_Error)
  := do
  TryFromInst.try_from self

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryInto<U, Clause0_Error> for T}]
    Source: 'core-models/src/core/convert.rs', lines 68:0-73:1 -/
@[reducible]
def convert.TryInto.Blanket {T : Type} {U : Type} {Clause0_Error : Type}
  (TryFromInst : convert.TryFrom U T Clause0_Error) : convert.TryInto T U
  Clause0_Error := {
  try_into := convert.TryInto.Blanket.try_into TryFromInst
}

/-- [core_models::convert::{impl core_models::convert::From<T> for T}::from]:
    Source: 'core-models/src/core/convert.rs', lines 76:4-78:5
    Visibility: public -/
def convert.From.Blanket.from {T : Type} (x : T) : RustM T := do
  ok x

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<T> for T}]
    Source: 'core-models/src/core/convert.rs', lines 75:0-79:1 -/
@[reducible]
def convert.From.Blanket (T : Type) : convert.From T T := {
  «from» := convert.From.Blanket.from
}

/-- [core_models::convert::{impl core_models::convert::AsRef<[T]> for [T]}::as_ref]:
    Source: 'core-models/src/core/convert.rs', lines 92:4-94:5
    Visibility: public -/
def Slice.Insts.CoreConvertAsRefSlice.as_ref
  {T : Type} (self : Slice T) : RustM (Slice T) := do
  ok self

/-- Trait implementation: [core_models::convert::{impl core_models::convert::AsRef<[T]> for [T]}]
    Source: 'core-models/src/core/convert.rs', lines 91:0-95:1 -/
@[reducible]
def Slice.Insts.CoreConvertAsRefSlice (T : Type) : convert.AsRef (Slice
  T) (Slice T) := {
  as_ref := Slice.Insts.CoreConvertAsRefSlice.as_ref
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for u16}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U16.Insts.CoreConvertFromU8.from (x : Std.U8) : RustM Std.U16 := do
  ok (UScalar.cast .U16 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U16.Insts.CoreConvertFromU8 : convert.From Std.U16 Std.U8 := {
  «from» := U16.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for u32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U32.Insts.CoreConvertFromU8.from (x : Std.U8) : RustM Std.U32 := do
  ok (UScalar.cast .U32 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U32.Insts.CoreConvertFromU8 : convert.From Std.U32 Std.U8 := {
  «from» := U32.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for u32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U32.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.U32 := do
  ok (UScalar.cast .U32 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U32.Insts.CoreConvertFromU16 : convert.From Std.U32 Std.U16 := {
  «from» := U32.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for u64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U64.Insts.CoreConvertFromU8.from (x : Std.U8) : RustM Std.U64 := do
  ok (UScalar.cast .U64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U64.Insts.CoreConvertFromU8 : convert.From Std.U64 Std.U8 := {
  «from» := U64.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for u64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U64.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.U64 := do
  ok (UScalar.cast .U64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U64.Insts.CoreConvertFromU16 : convert.From Std.U64 Std.U16 := {
  «from» := U64.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u32> for u64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U64.Insts.CoreConvertFromU32.from
  (x : Std.U32) : RustM Std.U64 := do
  ok (UScalar.cast .U64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u32> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U64.Insts.CoreConvertFromU32 : convert.From Std.U64 Std.U32 := {
  «from» := U64.Insts.CoreConvertFromU32.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for u128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U128.Insts.CoreConvertFromU8.from
  (x : Std.U8) : RustM Std.U128 := do
  ok (UScalar.cast .U128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U128.Insts.CoreConvertFromU8 : convert.From Std.U128 Std.U8 := {
  «from» := U128.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for u128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U128.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.U128 := do
  ok (UScalar.cast .U128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U128.Insts.CoreConvertFromU16 : convert.From Std.U128 Std.U16 := {
  «from» := U128.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u32> for u128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U128.Insts.CoreConvertFromU32.from
  (x : Std.U32) : RustM Std.U128 := do
  ok (UScalar.cast .U128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u32> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U128.Insts.CoreConvertFromU32 : convert.From Std.U128 Std.U32 := {
  «from» := U128.Insts.CoreConvertFromU32.from
}

/-- [core_models::convert::{impl core_models::convert::From<u64> for u128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def U128.Insts.CoreConvertFromU64.from
  (x : Std.U64) : RustM Std.U128 := do
  ok (UScalar.cast .U128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u64> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def U128.Insts.CoreConvertFromU64 : convert.From Std.U128 Std.U64 := {
  «from» := U128.Insts.CoreConvertFromU64.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for usize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def Usize.Insts.CoreConvertFromU8.from
  (x : Std.U8) : RustM Std.Usize := do
  ok (UScalar.cast .Usize x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def Usize.Insts.CoreConvertFromU8 : convert.From Std.Usize Std.U8 := {
  «from» := Usize.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for usize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def Usize.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.Usize := do
  ok (UScalar.cast .Usize x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def Usize.Insts.CoreConvertFromU16 : convert.From Std.Usize Std.U16 := {
  «from» := Usize.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<i8> for i16}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I16.Insts.CoreConvertFromI8.from (x : Std.I8) : RustM Std.I16 := do
  ok (IScalar.cast .I16 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i8> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I16.Insts.CoreConvertFromI8 : convert.From Std.I16 Std.I8 := {
  «from» := I16.Insts.CoreConvertFromI8.from
}

/-- [core_models::convert::{impl core_models::convert::From<i8> for i32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I32.Insts.CoreConvertFromI8.from (x : Std.I8) : RustM Std.I32 := do
  ok (IScalar.cast .I32 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i8> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I32.Insts.CoreConvertFromI8 : convert.From Std.I32 Std.I8 := {
  «from» := I32.Insts.CoreConvertFromI8.from
}

/-- [core_models::convert::{impl core_models::convert::From<i16> for i32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I32.Insts.CoreConvertFromI16.from
  (x : Std.I16) : RustM Std.I32 := do
  ok (IScalar.cast .I32 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i16> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I32.Insts.CoreConvertFromI16 : convert.From Std.I32 Std.I16 := {
  «from» := I32.Insts.CoreConvertFromI16.from
}

/-- [core_models::convert::{impl core_models::convert::From<i8> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I64.Insts.CoreConvertFromI8.from (x : Std.I8) : RustM Std.I64 := do
  ok (IScalar.cast .I64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i8> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I64.Insts.CoreConvertFromI8 : convert.From Std.I64 Std.I8 := {
  «from» := I64.Insts.CoreConvertFromI8.from
}

/-- [core_models::convert::{impl core_models::convert::From<i16> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I64.Insts.CoreConvertFromI16.from
  (x : Std.I16) : RustM Std.I64 := do
  ok (IScalar.cast .I64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i16> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I64.Insts.CoreConvertFromI16 : convert.From Std.I64 Std.I16 := {
  «from» := I64.Insts.CoreConvertFromI16.from
}

/-- [core_models::convert::{impl core_models::convert::From<i32> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I64.Insts.CoreConvertFromI32.from
  (x : Std.I32) : RustM Std.I64 := do
  ok (IScalar.cast .I64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i32> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I64.Insts.CoreConvertFromI32 : convert.From Std.I64 Std.I32 := {
  «from» := I64.Insts.CoreConvertFromI32.from
}

/-- [core_models::convert::{impl core_models::convert::From<i8> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromI8.from
  (x : Std.I8) : RustM Std.I128 := do
  ok (IScalar.cast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i8> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromI8 : convert.From Std.I128 Std.I8 := {
  «from» := I128.Insts.CoreConvertFromI8.from
}

/-- [core_models::convert::{impl core_models::convert::From<i16> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromI16.from
  (x : Std.I16) : RustM Std.I128 := do
  ok (IScalar.cast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i16> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromI16 : convert.From Std.I128 Std.I16 := {
  «from» := I128.Insts.CoreConvertFromI16.from
}

/-- [core_models::convert::{impl core_models::convert::From<i32> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromI32.from
  (x : Std.I32) : RustM Std.I128 := do
  ok (IScalar.cast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i32> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromI32 : convert.From Std.I128 Std.I32 := {
  «from» := I128.Insts.CoreConvertFromI32.from
}

/-- [core_models::convert::{impl core_models::convert::From<i64> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromI64.from
  (x : Std.I64) : RustM Std.I128 := do
  ok (IScalar.cast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i64> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromI64 : convert.From Std.I128 Std.I64 := {
  «from» := I128.Insts.CoreConvertFromI64.from
}

/-- [core_models::convert::{impl core_models::convert::From<i8> for isize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def Isize.Insts.CoreConvertFromI8.from
  (x : Std.I8) : RustM Std.Isize := do
  ok (IScalar.cast .Isize x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i8> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def Isize.Insts.CoreConvertFromI8 : convert.From Std.Isize Std.I8 := {
  «from» := Isize.Insts.CoreConvertFromI8.from
}

/-- [core_models::convert::{impl core_models::convert::From<i16> for isize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def Isize.Insts.CoreConvertFromI16.from
  (x : Std.I16) : RustM Std.Isize := do
  ok (IScalar.cast .Isize x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<i16> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def Isize.Insts.CoreConvertFromI16 : convert.From Std.Isize Std.I16 := {
  «from» := Isize.Insts.CoreConvertFromI16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for i16}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I16.Insts.CoreConvertFromU8.from (x : Std.U8) : RustM Std.I16 := do
  ok (UScalar.hcast .I16 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I16.Insts.CoreConvertFromU8 : convert.From Std.I16 Std.U8 := {
  «from» := I16.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for i32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I32.Insts.CoreConvertFromU8.from (x : Std.U8) : RustM Std.I32 := do
  ok (UScalar.hcast .I32 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I32.Insts.CoreConvertFromU8 : convert.From Std.I32 Std.U8 := {
  «from» := I32.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I64.Insts.CoreConvertFromU8.from (x : Std.U8) : RustM Std.I64 := do
  ok (UScalar.hcast .I64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I64.Insts.CoreConvertFromU8 : convert.From Std.I64 Std.U8 := {
  «from» := I64.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromU8.from
  (x : Std.U8) : RustM Std.I128 := do
  ok (UScalar.hcast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromU8 : convert.From Std.I128 Std.U8 := {
  «from» := I128.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u8> for isize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def Isize.Insts.CoreConvertFromU8.from
  (x : Std.U8) : RustM Std.Isize := do
  ok (UScalar.hcast .Isize x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u8> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def Isize.Insts.CoreConvertFromU8 : convert.From Std.Isize Std.U8 := {
  «from» := Isize.Insts.CoreConvertFromU8.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for i32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I32.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.I32 := do
  ok (UScalar.hcast .I32 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I32.Insts.CoreConvertFromU16 : convert.From Std.I32 Std.U16 := {
  «from» := I32.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I64.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.I64 := do
  ok (UScalar.hcast .I64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I64.Insts.CoreConvertFromU16 : convert.From Std.I64 Std.U16 := {
  «from» := I64.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u16> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromU16.from
  (x : Std.U16) : RustM Std.I128 := do
  ok (UScalar.hcast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u16> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromU16 : convert.From Std.I128 Std.U16 := {
  «from» := I128.Insts.CoreConvertFromU16.from
}

/-- [core_models::convert::{impl core_models::convert::From<u32> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I64.Insts.CoreConvertFromU32.from
  (x : Std.U32) : RustM Std.I64 := do
  ok (UScalar.hcast .I64 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u32> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I64.Insts.CoreConvertFromU32 : convert.From Std.I64 Std.U32 := {
  «from» := I64.Insts.CoreConvertFromU32.from
}

/-- [core_models::convert::{impl core_models::convert::From<u32> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromU32.from
  (x : Std.U32) : RustM Std.I128 := do
  ok (UScalar.hcast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u32> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromU32 : convert.From Std.I128 Std.U32 := {
  «from» := I128.Insts.CoreConvertFromU32.from
}

/-- [core_models::convert::{impl core_models::convert::From<u64> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 105:16-107:17
    Visibility: public -/
def I128.Insts.CoreConvertFromU64.from
  (x : Std.U64) : RustM Std.I128 := do
  ok (UScalar.hcast .I128 x)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<u64> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 104:12-108:13 -/
@[reducible]
def I128.Insts.CoreConvertFromU64 : convert.From Std.I128 Std.U64 := {
  «from» := I128.Insts.CoreConvertFromU64.from
}

/-
/-- [core_models::num::{core_models::num::u8}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 27:12-27:40
    Visibility: public -/
@[global_simps, irreducible] def num.U8.MAX : Std.U8 := 255#u8
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::u8}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 25:12-25:37
    Visibility: public -/
@[global_simps, irreducible] def num.U8.MIN : Std.U8 := 0#u8
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<u16, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromU16TryFromIntError.try_from
  (x : Std.U16) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U16 num.U8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U16 num.U8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u16, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromU16TryFromIntError : convert.TryFrom
  Std.U8 Std.U16 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromU16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromU32TryFromIntError.try_from
  (x : Std.U32) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U32 num.U8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U32 num.U8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromU32TryFromIntError : convert.TryFrom
  Std.U8 Std.U32 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromU32TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::u16}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 27:12-27:40
    Visibility: public -/
@[global_simps, irreducible] def num.U16.MAX : Std.U16 := 65535#u16
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::u16}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 25:12-25:37
    Visibility: public -/
@[global_simps, irreducible] def num.U16.MIN : Std.U16 := 0#u16
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromU32TryFromIntError.try_from
  (x : Std.U32) : RustM (result.Result Std.U16 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U32 num.U16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U32 num.U16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromU32TryFromIntError : convert.TryFrom
  Std.U16 Std.U32 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromU32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U64 num.U8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U64 num.U8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.U8 Std.U64 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.U16 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U64 num.U16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U64 num.U16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.U16 Std.U64 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::u32}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 27:12-27:40
    Visibility: public -/
@[global_simps, irreducible] def num.U32.MAX : Std.U32 := 4294967295#u32
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::u32}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 25:12-25:37
    Visibility: public -/
@[global_simps, irreducible] def num.U32.MIN : Std.U32 := 0#u32
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.U32 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U64 num.U32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U64 num.U32.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.U32 Std.U64 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::usize}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 27:12-27:40
    Visibility: public -/
@[global_simps, irreducible]
def num.Usize.MAX : RustM Std.Usize := rust_primitives.arithmetic.USIZE_MAX
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::usize}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 25:12-25:37
    Visibility: public -/
@[global_simps, irreducible] def num.Usize.MIN : Std.Usize := 0#usize
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  let i := num.Usize.MAX
  let i1 ← lift (UScalar.cast .U64 i)
  if x > i1
  then ok (result.Result.Err ())
  else
    let i2 ← lift (UScalar.cast .U64 num.Usize.MIN)
    if x < i2
    then ok (result.Result.Err ())
    else let i3 ← lift (UScalar.cast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.Usize Std.U64 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  let i ← lift (UScalar.cast .U128 num.U8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U128 num.U8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.U8 Std.U128 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.U16 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .U128 num.U16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U128 num.U16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.U16 Std.U128 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.U32 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .U128 num.U32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U128 num.U32.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.U32 Std.U128 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::u64}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 27:12-27:40
    Visibility: public -/
@[global_simps, irreducible]
def num.U64.MAX : Std.U64 := 18446744073709551615#u64
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::u64}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 25:12-25:37
    Visibility: public -/
@[global_simps, irreducible] def num.U64.MIN : Std.U64 := 0#u64
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.U64 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .U128 num.U64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .U128 num.U64.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.U64 Std.U128 num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  let i := num.Usize.MAX
  let i1 ← lift (UScalar.cast .U128 i)
  if x > i1
  then ok (result.Result.Err ())
  else
    let i2 ← lift (UScalar.cast .U128 num.Usize.MIN)
    if x < i2
    then ok (result.Result.Err ())
    else let i3 ← lift (UScalar.cast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.Usize Std.U128 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.U8 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .Usize num.U8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .Usize num.U8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.U8 Std.Usize num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.U16 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .Usize num.U16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .Usize num.U16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.U16 Std.Usize num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.U32 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .Usize num.U32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .Usize num.U32.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.U32 Std.Usize num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.U64 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .Usize num.U64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (UScalar.cast .Usize num.U64.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (UScalar.cast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.U64 Std.Usize num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::i8}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 274:12-274:40
    Visibility: public -/
@[global_simps, irreducible] def num.I8.MAX : Std.I8 := 127#i8
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::i8}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 272:12-272:40
    Visibility: public -/
@[global_simps, irreducible] def num.I8.MIN : Std.I8 := (-128)#i8
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I16 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I16 num.I8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.I8 Std.I16 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I32 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I32 num.I8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.I8 Std.I32 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::i16}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 274:12-274:40
    Visibility: public -/
@[global_simps, irreducible] def num.I16.MAX : Std.I16 := 32767#i16
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::i16}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 272:12-272:40
    Visibility: public -/
@[global_simps, irreducible] def num.I16.MIN : Std.I16 := (-32768)#i16
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) : RustM (result.Result Std.I16 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I32 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I32 num.I16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.I16 Std.I32 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I64 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I64 num.I8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.I8 Std.I64 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.I16 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I64 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I64 num.I16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.I16 Std.I64 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::i32}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 274:12-274:40
    Visibility: public -/
@[global_simps, irreducible] def num.I32.MAX : Std.I32 := 2147483647#i32
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::i32}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 272:12-272:40
    Visibility: public -/
@[global_simps, irreducible] def num.I32.MIN : Std.I32 := (-2147483648)#i32
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.I32 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I64 num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I64 num.I32.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.I32 Std.I64 num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::isize}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 274:12-274:40
    Visibility: public -/
@[global_simps, irreducible]
def num.Isize.MAX : RustM Std.Isize := rust_primitives.arithmetic.ISIZE_MAX
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::isize}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 272:12-272:40
    Visibility: public -/
@[global_simps, irreducible]
def num.Isize.MIN : RustM Std.Isize := rust_primitives.arithmetic.ISIZE_MIN
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for isize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def Isize.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) :
  RustM (result.Result Std.Isize num.error.TryFromIntError)
  := do
  let i := num.Isize.MAX
  let i1 ← lift (IScalar.cast .I64 i)
  if x > i1
  then ok (result.Result.Err ())
  else
    let i2 := num.Isize.MIN
    let i3 ← lift (IScalar.cast .I64 i2)
    if x < i3
    then ok (result.Result.Err ())
    else let i4 ← lift (IScalar.cast .Isize x)
         ok (result.Result.Ok i4)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def Isize.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.Isize Std.I64 num.error.TryFromIntError := {
  try_from := Isize.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.cast .I128 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I128 num.I8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.I8 Std.I128 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.I16 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .I128 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I128 num.I16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.I16 Std.I128 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.I32 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .I128 num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I128 num.I32.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.I32 Std.I128 num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::i64}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 274:12-274:40
    Visibility: public -/
@[global_simps, irreducible]
def num.I64.MAX : Std.I64 := 9223372036854775807#i64
-/  -- provided by CoreModels.Core.FunsPrologue

/-
/-- [core_models::num::{core_models::num::i64}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 272:12-272:40
    Visibility: public -/
@[global_simps, irreducible]
def num.I64.MIN : Std.I64 := (-9223372036854775808)#i64
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I64.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.I64 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .I128 num.I64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .I128 num.I64.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I64.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.I64 Std.I128 num.error.TryFromIntError := {
  try_from := I64.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for isize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def Isize.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.Isize num.error.TryFromIntError)
  := do
  let i := num.Isize.MAX
  let i1 ← lift (IScalar.cast .I128 i)
  if x > i1
  then ok (result.Result.Err ())
  else
    let i2 := num.Isize.MIN
    let i3 ← lift (IScalar.cast .I128 i2)
    if x < i3
    then ok (result.Result.Err ())
    else let i4 ← lift (IScalar.cast .Isize x)
         ok (result.Result.Ok i4)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def Isize.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.Isize Std.I128 num.error.TryFromIntError := {
  try_from := Isize.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.I8 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .Isize num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .Isize num.I8.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.I8 Std.Isize num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.I16 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .Isize num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .Isize num.I16.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.I16 Std.Isize num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.I32 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .Isize num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .Isize num.I32.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.I32 Std.Isize num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 126:16-132:17
    Visibility: public -/
def I64.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.I64 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .Isize num.I64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else
    let i1 ← lift (IScalar.cast .Isize num.I64.MIN)
    if x < i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.cast .I64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 124:12-133:13 -/
@[reducible]
def I64.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.I64 Std.Isize num.error.TryFromIntError := {
  try_from := I64.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for isize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 147:16-149:17
    Visibility: public -/
def Isize.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) :
  RustM (result.Result Std.Isize num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .Isize x)
  ok (result.Result.Ok i)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 145:12-150:13 -/
@[reducible]
def Isize.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.Isize Std.I32 num.error.TryFromIntError := {
  try_from := Isize.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 147:16-149:17
    Visibility: public -/
def I128.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.I128 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.cast .I128 x)
  ok (result.Result.Ok i)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 145:12-150:13 -/
@[reducible]
def I128.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.I128 Std.Isize num.error.TryFromIntError := {
  try_from := I128.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 147:16-149:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromU32TryFromIntError.try_from
  (x : Std.U32) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .Usize x)
  ok (result.Result.Ok i)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 145:12-150:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromU32TryFromIntError : convert.TryFrom
  Std.Usize Std.U32 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromU32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 147:16-149:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.U128 num.error.TryFromIntError)
  := do
  let i ← lift (UScalar.cast .U128 x)
  ok (result.Result.Ok i)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 145:12-150:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.U128 Std.Usize num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u8, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromU8TryFromIntError.try_from
  (x : Std.U8) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U8 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I8 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u8, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromU8TryFromIntError : convert.TryFrom
  Std.I8 Std.U8 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromU8TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u16, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromU16TryFromIntError.try_from
  (x : Std.U16) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U16 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I8 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u16, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromU16TryFromIntError : convert.TryFrom
  Std.I8 Std.U16 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromU16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u16, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromU16TryFromIntError.try_from
  (x : Std.U16) : RustM (result.Result Std.I16 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U16 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I16 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u16, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromU16TryFromIntError : convert.TryFrom
  Std.I16 Std.U16 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromU16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromU32TryFromIntError.try_from
  (x : Std.U32) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U32 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I8 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromU32TryFromIntError : convert.TryFrom
  Std.I8 Std.U32 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromU32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromU32TryFromIntError.try_from
  (x : Std.U32) : RustM (result.Result Std.I16 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U32 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I16 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromU32TryFromIntError : convert.TryFrom
  Std.I16 Std.U32 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromU32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromU32TryFromIntError.try_from
  (x : Std.U32) : RustM (result.Result Std.I32 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U32 num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I32 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u32, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromU32TryFromIntError : convert.TryFrom
  Std.I32 Std.U32 num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromU32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U64 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I8 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.I8 Std.U64 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.I16 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U64 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I16 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.I16 Std.U64 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.I32 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U64 num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I32 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.I32 Std.U64 num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I64.Insts.CoreConvertTryFromU64TryFromIntError.try_from
  (x : Std.U64) : RustM (result.Result Std.I64 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U64 num.I64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I64 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u64, core_models::num::error::TryFromIntError> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I64.Insts.CoreConvertTryFromU64TryFromIntError : convert.TryFrom
  Std.I64 Std.U64 num.error.TryFromIntError := {
  try_from := I64.Insts.CoreConvertTryFromU64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) : RustM (result.Result Std.I8 num.error.TryFromIntError) := do
  let i ← lift (IScalar.hcast .U128 num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I8 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.I8 Std.U128 num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.I16 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .U128 num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I16 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.I16 Std.U128 num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.I32 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .U128 num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I32 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.I32 Std.U128 num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I64.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.I64 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .U128 num.I64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I64 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I64.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.I64 Std.U128 num.error.TryFromIntError := {
  try_from := I64.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::i128}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 274:12-274:40
    Visibility: public -/
@[global_simps, irreducible]
def num.I128.MAX : Std.I128 := 170141183460469231731687303715884105727#i128
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I128.Insts.CoreConvertTryFromU128TryFromIntError.try_from
  (x : Std.U128) :
  RustM (result.Result Std.I128 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .U128 num.I128.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I128 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<u128, core_models::num::error::TryFromIntError> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I128.Insts.CoreConvertTryFromU128TryFromIntError : convert.TryFrom
  Std.I128 Std.U128 num.error.TryFromIntError := {
  try_from := I128.Insts.CoreConvertTryFromU128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.I8 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .Usize num.I8.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I8 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I8.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.I8 Std.Usize num.error.TryFromIntError := {
  try_from := I8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.I16 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .Usize num.I16.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I16 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I16.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.I16 Std.Usize num.error.TryFromIntError := {
  try_from := I16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.I32 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .Usize num.I32.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I32 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I32.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.I32 Std.Usize num.error.TryFromIntError := {
  try_from := I32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def I64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.I64 num.error.TryFromIntError)
  := do
  let i ← lift (IScalar.hcast .Usize num.I64.MAX)
  if x > i
  then ok (result.Result.Err ())
  else let i1 ← lift (UScalar.hcast .I64 x)
       ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def I64.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.I64 Std.Usize num.error.TryFromIntError := {
  try_from := I64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for isize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 195:16-201:17
    Visibility: public -/
def Isize.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
  (x : Std.Usize) :
  RustM (result.Result Std.Isize num.error.TryFromIntError)
  := do
  let i := num.Isize.MAX
  let i1 ← lift (IScalar.hcast .Usize i)
  if x > i1
  then ok (result.Result.Err ())
  else let i2 ← lift (UScalar.hcast .Isize x)
       ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<usize, core_models::num::error::TryFromIntError> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 193:12-202:13 -/
@[reducible]
def Isize.Insts.CoreConvertTryFromUsizeTryFromIntError : convert.TryFrom
  Std.Isize Std.Usize num.error.TryFromIntError := {
  try_from :=
    Isize.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromI8TryFromIntError.try_from
  (x : Std.I8) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  if x < 0#i8
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U8.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromI8TryFromIntError : convert.TryFrom
  Std.U8 Std.I8 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromI8TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromI8TryFromIntError.try_from
  (x : Std.I8) : RustM (result.Result Std.U16 num.error.TryFromIntError) := do
  if x < 0#i8
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U16.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromI8TryFromIntError : convert.TryFrom
  Std.U16 Std.I8 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromI8TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromI8TryFromIntError.try_from
  (x : Std.I8) : RustM (result.Result Std.U32 num.error.TryFromIntError) := do
  if x < 0#i8
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U32.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromI8TryFromIntError : convert.TryFrom
  Std.U32 Std.I8 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromI8TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromI8TryFromIntError.try_from
  (x : Std.I8) : RustM (result.Result Std.U64 num.error.TryFromIntError) := do
  if x < 0#i8
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U64.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromI8TryFromIntError : convert.TryFrom
  Std.U64 Std.I8 num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromI8TryFromIntError.try_from
}

/-
/-- [core_models::num::{core_models::num::u128}::MAX]
    Source: 'core-models/src/core/num/mod.rs', lines 27:12-27:40
    Visibility: public -/
@[global_simps, irreducible]
def num.U128.MAX : Std.U128 := 340282366920938463463374607431768211455#u128
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromI8TryFromIntError.try_from
  (x : Std.I8) : RustM (result.Result Std.U128 num.error.TryFromIntError) := do
  if x < 0#i8
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    if i > num.U128.MAX
    then ok (result.Result.Err ())
    else let i1 ← lift (IScalar.hcast .U128 x)
         ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromI8TryFromIntError : convert.TryFrom
  Std.U128 Std.I8 num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromI8TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromI8TryFromIntError.try_from
  (x : Std.I8) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  if x < 0#i8
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 := num.Usize.MAX
    let i2 ← lift (UScalar.cast .U128 i1)
    if i > i2
    then ok (result.Result.Err ())
    else let i3 ← lift (IScalar.hcast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i8, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromI8TryFromIntError : convert.TryFrom
  Std.Usize Std.I8 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromI8TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  if x < 0#i16
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U8.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.U8 Std.I16 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) : RustM (result.Result Std.U16 num.error.TryFromIntError) := do
  if x < 0#i16
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U16.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.U16 Std.I16 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) : RustM (result.Result Std.U32 num.error.TryFromIntError) := do
  if x < 0#i16
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U32.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.U32 Std.I16 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) : RustM (result.Result Std.U64 num.error.TryFromIntError) := do
  if x < 0#i16
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U64.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.U64 Std.I16 num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) :
  RustM (result.Result Std.U128 num.error.TryFromIntError)
  := do
  if x < 0#i16
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    if i > num.U128.MAX
    then ok (result.Result.Err ())
    else let i1 ← lift (IScalar.hcast .U128 x)
         ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.U128 Std.I16 num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromI16TryFromIntError.try_from
  (x : Std.I16) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  if x < 0#i16
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 := num.Usize.MAX
    let i2 ← lift (UScalar.cast .U128 i1)
    if i > i2
    then ok (result.Result.Err ())
    else let i3 ← lift (IScalar.hcast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i16, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromI16TryFromIntError : convert.TryFrom
  Std.Usize Std.I16 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromI16TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  if x < 0#i32
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U8.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.U8 Std.I32 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) : RustM (result.Result Std.U16 num.error.TryFromIntError) := do
  if x < 0#i32
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U16.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.U16 Std.I32 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) : RustM (result.Result Std.U32 num.error.TryFromIntError) := do
  if x < 0#i32
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U32.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.U32 Std.I32 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) : RustM (result.Result Std.U64 num.error.TryFromIntError) := do
  if x < 0#i32
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U64.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.U64 Std.I32 num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) :
  RustM (result.Result Std.U128 num.error.TryFromIntError)
  := do
  if x < 0#i32
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    if i > num.U128.MAX
    then ok (result.Result.Err ())
    else let i1 ← lift (IScalar.hcast .U128 x)
         ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.U128 Std.I32 num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromI32TryFromIntError.try_from
  (x : Std.I32) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  if x < 0#i32
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 := num.Usize.MAX
    let i2 ← lift (UScalar.cast .U128 i1)
    if i > i2
    then ok (result.Result.Err ())
    else let i3 ← lift (IScalar.hcast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i32, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromI32TryFromIntError : convert.TryFrom
  Std.Usize Std.I32 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromI32TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  if x < 0#i64
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U8.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.U8 Std.I64 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.U16 num.error.TryFromIntError) := do
  if x < 0#i64
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U16.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.U16 Std.I64 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.U32 num.error.TryFromIntError) := do
  if x < 0#i64
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U32.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.U32 Std.I64 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) : RustM (result.Result Std.U64 num.error.TryFromIntError) := do
  if x < 0#i64
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U64.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.U64 Std.I64 num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) :
  RustM (result.Result Std.U128 num.error.TryFromIntError)
  := do
  if x < 0#i64
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    if i > num.U128.MAX
    then ok (result.Result.Err ())
    else let i1 ← lift (IScalar.hcast .U128 x)
         ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.U128 Std.I64 num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromI64TryFromIntError.try_from
  (x : Std.I64) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  if x < 0#i64
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 := num.Usize.MAX
    let i2 ← lift (UScalar.cast .U128 i1)
    if i > i2
    then ok (result.Result.Err ())
    else let i3 ← lift (IScalar.hcast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i64, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromI64TryFromIntError : convert.TryFrom
  Std.Usize Std.I64 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromI64TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) : RustM (result.Result Std.U8 num.error.TryFromIntError) := do
  if x < 0#i128
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U8.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.U8 Std.I128 num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.U16 num.error.TryFromIntError)
  := do
  if x < 0#i128
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U16.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.U16 Std.I128 num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.U32 num.error.TryFromIntError)
  := do
  if x < 0#i128
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U32.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.U32 Std.I128 num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.U64 num.error.TryFromIntError)
  := do
  if x < 0#i128
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U64.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.U64 Std.I128 num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.U128 num.error.TryFromIntError)
  := do
  if x < 0#i128
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    if i > num.U128.MAX
    then ok (result.Result.Err ())
    else let i1 ← lift (IScalar.hcast .U128 x)
         ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.U128 Std.I128 num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromI128TryFromIntError.try_from
  (x : Std.I128) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  if x < 0#i128
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 := num.Usize.MAX
    let i2 ← lift (UScalar.cast .U128 i1)
    if i > i2
    then ok (result.Result.Err ())
    else let i3 ← lift (IScalar.hcast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<i128, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromI128TryFromIntError : convert.TryFrom
  Std.Usize Std.I128 num.error.TryFromIntError := {
  try_from := Usize.Insts.CoreConvertTryFromI128TryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u8}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U8.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.U8 num.error.TryFromIntError)
  := do
  if x < 0#isize
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U8.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U8 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U8.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.U8 Std.Isize num.error.TryFromIntError := {
  try_from := U8.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u16}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U16.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.U16 num.error.TryFromIntError)
  := do
  if x < 0#isize
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U16.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U16 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U16.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.U16 Std.Isize num.error.TryFromIntError := {
  try_from := U16.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u32}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U32.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.U32 num.error.TryFromIntError)
  := do
  if x < 0#isize
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U32.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U32 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U32.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.U32 Std.Isize num.error.TryFromIntError := {
  try_from := U32.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u64}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U64.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.U64 num.error.TryFromIntError)
  := do
  if x < 0#isize
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 ← lift (UScalar.cast .U128 num.U64.MAX)
    if i > i1
    then ok (result.Result.Err ())
    else let i2 ← lift (IScalar.hcast .U64 x)
         ok (result.Result.Ok i2)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U64.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.U64 Std.Isize num.error.TryFromIntError := {
  try_from := U64.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u128}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def U128.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.U128 num.error.TryFromIntError)
  := do
  if x < 0#isize
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    if i > num.U128.MAX
    then ok (result.Result.Err ())
    else let i1 ← lift (IScalar.hcast .U128 x)
         ok (result.Result.Ok i1)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def U128.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.U128 Std.Isize num.error.TryFromIntError := {
  try_from := U128.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for usize}::try_from]:
    Source: 'core-models/src/core/convert.rs', lines 217:16-223:17
    Visibility: public -/
def Usize.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
  (x : Std.Isize) :
  RustM (result.Result Std.Usize num.error.TryFromIntError)
  := do
  if x < 0#isize
  then ok (result.Result.Err ())
  else
    let i ← lift (IScalar.hcast .U128 x)
    let i1 := num.Usize.MAX
    let i2 ← lift (UScalar.cast .U128 i1)
    if i > i2
    then ok (result.Result.Err ())
    else let i3 ← lift (IScalar.hcast .Usize x)
         ok (result.Result.Ok i3)

/-- Trait implementation: [core_models::convert::{impl core_models::convert::TryFrom<isize, core_models::num::error::TryFromIntError> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 214:12-224:13 -/
@[reducible]
def Usize.Insts.CoreConvertTryFromIsizeTryFromIntError : convert.TryFrom
  Std.Usize Std.Isize num.error.TryFromIntError := {
  try_from :=
    Usize.Insts.CoreConvertTryFromIsizeTryFromIntError.try_from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for u8}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def U8.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.U8 := do
  if x
  then ok 1#u8
  else ok 0#u8

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for u8}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def U8.Insts.CoreConvertFromBool : convert.From Std.U8 Bool := {
  «from» := U8.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for u16}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def U16.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.U16 := do
  if x
  then ok 1#u16
  else ok 0#u16

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for u16}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def U16.Insts.CoreConvertFromBool : convert.From Std.U16 Bool := {
  «from» := U16.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for u32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def U32.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.U32 := do
  if x
  then ok 1#u32
  else ok 0#u32

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for u32}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def U32.Insts.CoreConvertFromBool : convert.From Std.U32 Bool := {
  «from» := U32.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for u64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def U64.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.U64 := do
  if x
  then ok 1#u64
  else ok 0#u64

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for u64}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def U64.Insts.CoreConvertFromBool : convert.From Std.U64 Bool := {
  «from» := U64.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for u128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def U128.Insts.CoreConvertFromBool.from
  (x : Bool) : RustM Std.U128 := do
  if x
  then ok 1#u128
  else ok 0#u128

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for u128}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def U128.Insts.CoreConvertFromBool : convert.From Std.U128 Bool := {
  «from» := U128.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for usize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def Usize.Insts.CoreConvertFromBool.from
  (x : Bool) : RustM Std.Usize := do
  if x
  then ok 1#usize
  else ok 0#usize

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for usize}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def Usize.Insts.CoreConvertFromBool : convert.From Std.Usize Bool := {
  «from» := Usize.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for i8}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def I8.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.I8 := do
  if x
  then ok 1#i8
  else ok 0#i8

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for i8}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def I8.Insts.CoreConvertFromBool : convert.From Std.I8 Bool := {
  «from» := I8.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for i16}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def I16.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.I16 := do
  if x
  then ok 1#i16
  else ok 0#i16

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for i16}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def I16.Insts.CoreConvertFromBool : convert.From Std.I16 Bool := {
  «from» := I16.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for i32}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def I32.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.I32 := do
  if x
  then ok 1#i32
  else ok 0#i32

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for i32}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def I32.Insts.CoreConvertFromBool : convert.From Std.I32 Bool := {
  «from» := I32.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for i64}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def I64.Insts.CoreConvertFromBool.from (x : Bool) : RustM Std.I64 := do
  if x
  then ok 1#i64
  else ok 0#i64

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for i64}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def I64.Insts.CoreConvertFromBool : convert.From Std.I64 Bool := {
  «from» := I64.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for i128}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def I128.Insts.CoreConvertFromBool.from
  (x : Bool) : RustM Std.I128 := do
  if x
  then ok 1#i128
  else ok 0#i128

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for i128}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def I128.Insts.CoreConvertFromBool : convert.From Std.I128 Bool := {
  «from» := I128.Insts.CoreConvertFromBool.from
}

/-- [core_models::convert::{impl core_models::convert::From<bool> for isize}::from]:
    Source: 'core-models/src/core/convert.rs', lines 249:16-251:17
    Visibility: public -/
def Isize.Insts.CoreConvertFromBool.from
  (x : Bool) : RustM Std.Isize := do
  if x
  then ok 1#isize
  else ok 0#isize

/-- Trait implementation: [core_models::convert::{impl core_models::convert::From<bool> for isize}]
    Source: 'core-models/src/core/convert.rs', lines 248:12-252:13 -/
@[reducible]
def Isize.Insts.CoreConvertFromBool : convert.From Std.Isize Bool := {
  «from» := Isize.Insts.CoreConvertFromBool.from
}

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_struct_field1_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 17:8-23:9
    Visibility: public -/
def fmt.Formatter.debug_struct_field1_finish
  {T1 : Type} (DebugInst : fmt.Debug T1) (self : fmt.Formatter)
  (struct_name : Str) (name1 : Str) (value1 : T1) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_struct_field2_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 17:8-23:9
    Visibility: public -/
def fmt.Formatter.debug_struct_field2_finish
  {T1 : Type} {T2 : Type} (DebugInst : fmt.Debug T1) (DebugInst1 : fmt.Debug
  T2) (self : fmt.Formatter) (struct_name : Str) (name1 : Str) (value1 : T1)
  (name2 : Str) (value2 : T2) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_struct_field3_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 17:8-23:9
    Visibility: public -/
def fmt.Formatter.debug_struct_field3_finish
  {T1 : Type} {T2 : Type} {T3 : Type} (DebugInst : fmt.Debug T1) (DebugInst1 :
  fmt.Debug T2) (DebugInst2 : fmt.Debug T3) (self : fmt.Formatter)
  (struct_name : Str) (name1 : Str) (value1 : T1) (name2 : Str) (value2 : T2)
  (name3 : Str) (value3 : T3) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_struct_field4_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 17:8-23:9
    Visibility: public -/
def fmt.Formatter.debug_struct_field4_finish
  {T1 : Type} {T2 : Type} {T3 : Type} {T4 : Type} (DebugInst : fmt.Debug T1)
  (DebugInst1 : fmt.Debug T2) (DebugInst2 : fmt.Debug T3) (DebugInst3 :
  fmt.Debug T4) (self : fmt.Formatter) (struct_name : Str) (name1 : Str)
  (value1 : T1) (name2 : Str) (value2 : T2) (name3 : Str) (value3 : T3)
  (name4 : Str) (value4 : T4) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_struct_field5_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 17:8-23:9
    Visibility: public -/
def fmt.Formatter.debug_struct_field5_finish
  {T1 : Type} {T2 : Type} {T3 : Type} {T4 : Type} {T5 : Type} (DebugInst :
  fmt.Debug T1) (DebugInst1 : fmt.Debug T2) (DebugInst2 : fmt.Debug T3)
  (DebugInst3 : fmt.Debug T4) (DebugInst4 : fmt.Debug T5)
  (self : fmt.Formatter) (struct_name : Str) (name1 : Str) (value1 : T1)
  (name2 : Str) (value2 : T2) (name3 : Str) (value3 : T3) (name4 : Str)
  (value4 : T4) (name5 : Str) (value5 : T5) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::write_str]:
    Source: 'core-models/src/core/fmt.rs', lines 28:4-30:5
    Visibility: public -/
def fmt.Formatter.write_str
  (self : fmt.Formatter) (data : Str) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_struct_fields_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 54:4-66:5
    Visibility: public -/
def fmt.Formatter.debug_struct_fields_finish
  {T : Type} (DebugInst : fmt.Debug T) (self : fmt.Formatter)
  (struct_name : Str) (names : Slice Str) (values : Slice T) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  let i ← rust_primitives.slice.slice_length names
  let i1 ← rust_primitives.slice.slice_length values
  if i != i1
  then panicking.internal.panic Unit
       ok (result.Result.Ok (), self)
  else ok (result.Result.Ok (), self)

/-- [core_models::fmt::{core_models::fmt::Formatter}::debug_tuple_field1_finish]:
    Source: 'core-models/src/core/fmt.rs', lines 69:4-75:5
    Visibility: public -/
def fmt.Formatter.debug_tuple_field1_finish
  {T1 : Type} (DebugInst : fmt.Debug T1) (self : fmt.Formatter)
  (struct_name : Str) (value1 : T1) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), self)

/-- [core_models::fmt::{impl core_models::fmt::Debug for &'_0 T}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 110:4-112:5
    Visibility: public -/
def Shared0T.Insts.CoreFmtDebug.fmt
  {T : Type} (DebugInst : fmt.Debug T) (self : T) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  DebugInst.fmt self f

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Debug for &'_0 T}]
    Source: 'core-models/src/core/fmt.rs', lines 109:0-113:1 -/
@[reducible]
def Shared0T.Insts.CoreFmtDebug {T : Type} (DebugInst : fmt.Debug T) :
  fmt.Debug T := {
  fmt := Shared0T.Insts.CoreFmtDebug.fmt DebugInst
}

/-- [core_models::fmt::{impl core_models::fmt::Debug for bool}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 118:4-120:5
    Visibility: public -/
def Bool.Insts.CoreFmtDebug.fmt
  (self : Bool) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Debug for bool}]
    Source: 'core-models/src/core/fmt.rs', lines 117:0-121:1 -/
@[reducible]
def Bool.Insts.CoreFmtDebug : fmt.Debug Bool := {
  fmt := Bool.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Debug for ()}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 126:4-128:5
    Visibility: public -/
def Tuple.Insts.CoreFmtDebug.fmt
  (_ : Unit) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Debug for ()}]
    Source: 'core-models/src/core/fmt.rs', lines 125:0-129:1 -/
@[reducible]
def Tuple.Insts.CoreFmtDebug : fmt.Debug Unit := {
  fmt := Tuple.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for u8}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def U8.Insts.CoreFmtDebug.fmt
  (self : Std.U8) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for u8}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def U8.Insts.CoreFmtDebug : fmt.Debug Std.U8 := {
  fmt := U8.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for u16}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def U16.Insts.CoreFmtDebug.fmt
  (self : Std.U16) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for u16}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def U16.Insts.CoreFmtDebug : fmt.Debug Std.U16 := {
  fmt := U16.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for u32}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def U32.Insts.CoreFmtDebug.fmt
  (self : Std.U32) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for u32}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def U32.Insts.CoreFmtDebug : fmt.Debug Std.U32 := {
  fmt := U32.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for u64}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def U64.Insts.CoreFmtDebug.fmt
  (self : Std.U64) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for u64}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def U64.Insts.CoreFmtDebug : fmt.Debug Std.U64 := {
  fmt := U64.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for u128}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def U128.Insts.CoreFmtDebug.fmt
  (self : Std.U128) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for u128}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def U128.Insts.CoreFmtDebug : fmt.Debug Std.U128 := {
  fmt := U128.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for usize}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def Usize.Insts.CoreFmtDebug.fmt
  (self : Std.Usize) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for usize}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def Usize.Insts.CoreFmtDebug : fmt.Debug Std.Usize := {
  fmt := Usize.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for i8}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def I8.Insts.CoreFmtDebug.fmt
  (self : Std.I8) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for i8}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def I8.Insts.CoreFmtDebug : fmt.Debug Std.I8 := {
  fmt := I8.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for i16}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def I16.Insts.CoreFmtDebug.fmt
  (self : Std.I16) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for i16}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def I16.Insts.CoreFmtDebug : fmt.Debug Std.I16 := {
  fmt := I16.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for i32}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def I32.Insts.CoreFmtDebug.fmt
  (self : Std.I32) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for i32}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def I32.Insts.CoreFmtDebug : fmt.Debug Std.I32 := {
  fmt := I32.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for i64}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def I64.Insts.CoreFmtDebug.fmt
  (self : Std.I64) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for i64}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def I64.Insts.CoreFmtDebug : fmt.Debug Std.I64 := {
  fmt := I64.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for i128}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def I128.Insts.CoreFmtDebug.fmt
  (self : Std.I128) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for i128}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def I128.Insts.CoreFmtDebug : fmt.Debug Std.I128 := {
  fmt := I128.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::num::{impl core_models::fmt::Debug for isize}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 142:20-144:21
    Visibility: public -/
def Isize.Insts.CoreFmtDebug.fmt
  (self : Std.Isize) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::num::{impl core_models::fmt::Debug for isize}]
    Source: 'core-models/src/core/fmt.rs', lines 141:16-145:17 -/
@[reducible]
def Isize.Insts.CoreFmtDebug : fmt.Debug Std.Isize := {
  fmt := Isize.Insts.CoreFmtDebug.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for u8}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def U8.Insts.CoreFmtDisplay.fmt
  (self : Std.U8) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for u8}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def U8.Insts.CoreFmtDisplay : fmt.Display Std.U8 := {
  fmt := U8.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for u16}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def U16.Insts.CoreFmtDisplay.fmt
  (self : Std.U16) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for u16}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def U16.Insts.CoreFmtDisplay : fmt.Display Std.U16 := {
  fmt := U16.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for u32}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def U32.Insts.CoreFmtDisplay.fmt
  (self : Std.U32) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for u32}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def U32.Insts.CoreFmtDisplay : fmt.Display Std.U32 := {
  fmt := U32.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for u64}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def U64.Insts.CoreFmtDisplay.fmt
  (self : Std.U64) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for u64}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def U64.Insts.CoreFmtDisplay : fmt.Display Std.U64 := {
  fmt := U64.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for u128}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def U128.Insts.CoreFmtDisplay.fmt
  (self : Std.U128) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for u128}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def U128.Insts.CoreFmtDisplay : fmt.Display Std.U128 := {
  fmt := U128.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for usize}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def Usize.Insts.CoreFmtDisplay.fmt
  (self : Std.Usize) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for usize}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def Usize.Insts.CoreFmtDisplay : fmt.Display Std.Usize := {
  fmt := Usize.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for i8}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def I8.Insts.CoreFmtDisplay.fmt
  (self : Std.I8) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for i8}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def I8.Insts.CoreFmtDisplay : fmt.Display Std.I8 := {
  fmt := I8.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for i16}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def I16.Insts.CoreFmtDisplay.fmt
  (self : Std.I16) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for i16}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def I16.Insts.CoreFmtDisplay : fmt.Display Std.I16 := {
  fmt := I16.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for i32}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def I32.Insts.CoreFmtDisplay.fmt
  (self : Std.I32) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for i32}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def I32.Insts.CoreFmtDisplay : fmt.Display Std.I32 := {
  fmt := I32.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for i64}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def I64.Insts.CoreFmtDisplay.fmt
  (self : Std.I64) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for i64}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def I64.Insts.CoreFmtDisplay : fmt.Display Std.I64 := {
  fmt := I64.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for i128}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def I128.Insts.CoreFmtDisplay.fmt
  (self : Std.I128) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for i128}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def I128.Insts.CoreFmtDisplay : fmt.Display Std.I128 := {
  fmt := I128.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{impl core_models::fmt::Display for isize}::fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 172:16-174:17
    Visibility: public -/
def Isize.Insts.CoreFmtDisplay.fmt
  (self : Std.Isize) (f : fmt.Formatter) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- Trait implementation: [core_models::fmt::{impl core_models::fmt::Display for isize}]
    Source: 'core-models/src/core/fmt.rs', lines 171:12-175:13 -/
@[reducible]
def Isize.Insts.CoreFmtDisplay : fmt.Display Std.Isize := {
  fmt := Isize.Insts.CoreFmtDisplay.fmt
}

/-- [core_models::fmt::{core_models::fmt::Arguments<'a>}::write_fmt]:
    Source: 'core-models/src/core/fmt.rs', lines 206:4-208:5 -/
def fmt.Arguments.write_fmt
  (f : fmt.Formatter) (args : fmt.Arguments) :
  RustM ((result.Result Unit fmt.Error) × fmt.Formatter)
  := do
  ok (result.Result.Ok (), f)

/-- [core_models::fmt::rt::{core_models::fmt::rt::Argument<'a>}::none]:
    Source: 'core-models/src/core/fmt.rs', lines 295:8-297:9 -/
def fmt.rt.Argument.none : RustM (Array fmt.rt.Argument 0#usize) := do
  ok (Std.Array.empty fmt.rt.Argument)

/-- [core_models::hash::{impl core_models::hash::Hash for u8}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def U8.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.U8) (h : H) :
  RustM H
  := do
  let s ← lift (Array.to_slice (Array.make 1#usize [ self ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for u8}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def U8.Insts.CoreHashHash : hash.Hash Std.U8 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    U8.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for u16}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def U16.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.U16) (h : H) :
  RustM H
  := do
  let i ← lift (UScalar.cast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for u16}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def U16.Insts.CoreHashHash : hash.Hash Std.U16 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    U16.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for u32}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def U32.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.U32) (h : H) :
  RustM H
  := do
  let i ← lift (UScalar.cast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for u32}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def U32.Insts.CoreHashHash : hash.Hash Std.U32 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    U32.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for u64}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def U64.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.U64) (h : H) :
  RustM H
  := do
  let i ← lift (UScalar.cast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for u64}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def U64.Insts.CoreHashHash : hash.Hash Std.U64 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    U64.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for u128}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def U128.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.U128) (h : H) :
  RustM H
  := do
  let i ← lift (UScalar.cast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for u128}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def U128.Insts.CoreHashHash : hash.Hash Std.U128 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    U128.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for usize}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def Usize.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.Usize) (h : H) :
  RustM H
  := do
  let i ← lift (UScalar.cast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for usize}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def Usize.Insts.CoreHashHash : hash.Hash Std.Usize := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    Usize.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for i8}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def I8.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.I8) (h : H) :
  RustM H
  := do
  let i ← lift (IScalar.hcast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for i8}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def I8.Insts.CoreHashHash : hash.Hash Std.I8 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    I8.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for i16}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def I16.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.I16) (h : H) :
  RustM H
  := do
  let i ← lift (IScalar.hcast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for i16}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def I16.Insts.CoreHashHash : hash.Hash Std.I16 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    I16.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for i32}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def I32.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.I32) (h : H) :
  RustM H
  := do
  let i ← lift (IScalar.hcast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for i32}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def I32.Insts.CoreHashHash : hash.Hash Std.I32 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    I32.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for i64}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def I64.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.I64) (h : H) :
  RustM H
  := do
  let i ← lift (IScalar.hcast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for i64}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def I64.Insts.CoreHashHash : hash.Hash Std.I64 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    I64.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for i128}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def I128.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.I128) (h : H) :
  RustM H
  := do
  let i ← lift (IScalar.hcast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for i128}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def I128.Insts.CoreHashHash : hash.Hash Std.I128 := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    I128.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hash::{impl core_models::hash::Hash for isize}::hash]:
    Source: 'core-models/src/core/hash.rs', lines 27:16-30:17
    Visibility: public -/
def Isize.Insts.CoreHashHash.hash
  {H : Type} (HasherInst : hash.Hasher H) (self : Std.Isize) (h : H) :
  RustM H
  := do
  let i ← lift (IScalar.hcast .U8 self)
  let s ← lift (Array.to_slice (Array.make 1#usize [ i ]))
  HasherInst.write h s

/-- Trait implementation: [core_models::hash::{impl core_models::hash::Hash for isize}]
    Source: 'core-models/src/core/hash.rs', lines 26:12-31:13 -/
@[reducible]
def Isize.Insts.CoreHashHash : hash.Hash Std.Isize := {
  hash := fun {H : Type} (HasherInst : hash.Hasher H) =>
    Isize.Insts.CoreHashHash.hash HasherInst
}

/-- [core_models::hint::black_box]:
    Source: 'core-models/src/core/hint.rs', lines 3:0-5:1
    Visibility: public -/
def hint.black_box {T : Type} (dummy : T) : RustM T := do
  ok dummy

/-- [core_models::hint::must_use]:
    Source: 'core-models/src/core/hint.rs', lines 9:0-11:1
    Visibility: public -/
def hint.must_use {T : Type} (value : T) : RustM T := do
  ok value

/-- [core_models::intrinsics::unreachable]:
    Source: 'core-models/src/core/intrinsics.rs', lines 5:0-7:1
    Visibility: public -/
def intrinsics.unreachable : RustM Never := do
  fail Error.panic

/-- [core_models::iter::traits::iterator::iter_fold]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 118:12-120:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_fold_loop.body
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (coreopsfunctionFnMutFPairBInst
  : core.ops.function.FnMut F (B × Clause0_Item) B) (iter1 : I) (f : F)
  (accum : B) :
  RustM (ControlFlow (I × F × B) B)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (accum1, f1) ← coreopsfunctionFnMutFPairBInst.call_mut f (accum, x)
    ok (cont (iter2, f1, accum1))
  | option.Option.None => ok (done accum)

/-- [core_models::iter::traits::iterator::iter_fold]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 118:12-120:13 -/
@[rust_loop]
def iter.traits.iterator.iter_fold_loop
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (coreopsfunctionFnMutFPairBInst
  : core.ops.function.FnMut F (B × Clause0_Item) B) (iter1 : I) (f : F)
  (accum : B) :
  RustM B
  := do
  loop
    (fun (iter2, f1, accum1) => iter.traits.iterator.iter_fold_loop.body
      IteratorInst coreopsfunctionFnMutFPairBInst iter2 f1 accum1)
    (iter1, f, accum)

/-- [core_models::iter::traits::iterator::iter_fold]:
    Source: 'core-models/src/core/iter.rs', lines 112:8-122:9 -/
@[reducible]
def iter.traits.iterator.iter_fold
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (coreopsfunctionFnMutFPairBInst
  : core.ops.function.FnMut F (B × Clause0_Item) B) (iter1 : I) (init : B)
  (f : F) :
  RustM B
  := do
  iter.traits.iterator.iter_fold_loop IteratorInst
    coreopsfunctionFnMutFPairBInst iter1 f init

/-- [core_models::iter::traits::iterator::iter_all]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 127:12-133:9 -/
@[rust_loop_body]
def iter.traits.iterator.iter_all_loop.body
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemBoolInst : core.ops.function.FnMut F
  Clause0_Item Bool) (iter1 : I) (f : F) :
  RustM (ControlFlow (I × F) (Bool × I))
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (b, f1) ← coreopsfunctionFnMutFTupleClause0_ItemBoolInst.call_mut f x
    if b
    then ok (cont (iter2, f1))
    else ok (done (false, iter2))
  | option.Option.None => ok (done (true, iter2))

/-- [core_models::iter::traits::iterator::iter_all]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 127:12-133:9 -/
@[rust_loop]
def iter.traits.iterator.iter_all_loop
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemBoolInst : core.ops.function.FnMut F
  Clause0_Item Bool) (iter1 : I) (f : F) :
  RustM (Bool × I)
  := do
  loop
    (fun (iter2, f1) => iter.traits.iterator.iter_all_loop.body IteratorInst
      coreopsfunctionFnMutFTupleClause0_ItemBoolInst iter2 f1)
    (iter1, f)

/-- [core_models::iter::traits::iterator::iter_all]:
    Source: 'core-models/src/core/iter.rs', lines 126:8-133:9 -/
@[reducible]
def iter.traits.iterator.iter_all
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemBoolInst : core.ops.function.FnMut F
  Clause0_Item Bool) (iter1 : I) (f : F) :
  RustM (Bool × I)
  := do
  iter.traits.iterator.iter_all_loop IteratorInst
    coreopsfunctionFnMutFTupleClause0_ItemBoolInst iter1 f

/-- [core_models::iter::traits::iterator::iter_any]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 138:12-144:9 -/
@[rust_loop_body]
def iter.traits.iterator.iter_any_loop.body
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemBoolInst : core.ops.function.FnMut F
  Clause0_Item Bool) (iter1 : I) (f : F) :
  RustM (ControlFlow (I × F) (Bool × I))
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (b, f1) ← coreopsfunctionFnMutFTupleClause0_ItemBoolInst.call_mut f x
    if b
    then ok (done (true, iter2))
    else ok (cont (iter2, f1))
  | option.Option.None => ok (done (false, iter2))

/-- [core_models::iter::traits::iterator::iter_any]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 138:12-144:9 -/
@[rust_loop]
def iter.traits.iterator.iter_any_loop
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemBoolInst : core.ops.function.FnMut F
  Clause0_Item Bool) (iter1 : I) (f : F) :
  RustM (Bool × I)
  := do
  loop
    (fun (iter2, f1) => iter.traits.iterator.iter_any_loop.body IteratorInst
      coreopsfunctionFnMutFTupleClause0_ItemBoolInst iter2 f1)
    (iter1, f)

/-- [core_models::iter::traits::iterator::iter_any]:
    Source: 'core-models/src/core/iter.rs', lines 137:8-144:9 -/
@[reducible]
def iter.traits.iterator.iter_any
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemBoolInst : core.ops.function.FnMut F
  Clause0_Item Bool) (iter1 : I) (f : F) :
  RustM (Bool × I)
  := do
  iter.traits.iterator.iter_any_loop IteratorInst
    coreopsfunctionFnMutFTupleClause0_ItemBoolInst iter1 f

/-- [core_models::iter::traits::iterator::iter_find]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 152:12-158:9 -/
@[rust_loop_body]
def iter.traits.iterator.iter_find_loop.body
  {I : Type} {P : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool) (iter1 : I) (predicate : P) :
  RustM (ControlFlow (I × P) ((option.Option Clause0_Item) × I))
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (b, predicate1) ←
      coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst.call_mut predicate x
    if b
    then ok (done (o, iter2))
    else ok (cont (iter2, predicate1))
  | option.Option.None => ok (done (option.Option.None, iter2))

/-- [core_models::iter::traits::iterator::iter_find]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 152:12-158:9 -/
@[rust_loop]
def iter.traits.iterator.iter_find_loop
  {I : Type} {P : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool) (iter1 : I) (predicate : P) :
  RustM ((option.Option Clause0_Item) × I)
  := do
  loop
    (fun (iter2, predicate1) => iter.traits.iterator.iter_find_loop.body
      IteratorInst coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst iter2
      predicate1)
    (iter1, predicate)

/-- [core_models::iter::traits::iterator::iter_find]:
    Source: 'core-models/src/core/iter.rs', lines 148:8-158:9 -/
@[reducible]
def iter.traits.iterator.iter_find
  {I : Type} {P : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool) (iter1 : I) (predicate : P) :
  RustM ((option.Option Clause0_Item) × I)
  := do
  iter.traits.iterator.iter_find_loop IteratorInst
    coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst iter1 predicate

/-- [core_models::iter::traits::iterator::iter_find_map]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 166:12-172:9 -/
@[rust_loop_body]
def iter.traits.iterator.iter_find_map_loop.body
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B)) (iter1 : I) (f : F) :
  RustM (ControlFlow (I × F) ((option.Option B) × I))
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (o1, f1) ←
      coreopsfunctionFnMutFTupleClause0_ItemOptionInst.call_mut f x
    match o1 with
    | option.Option.Some _ => ok (done (o1, iter2))
    | option.Option.None => ok (cont (iter2, f1))
  | option.Option.None => ok (done (option.Option.None, iter2))

/-- [core_models::iter::traits::iterator::iter_find_map]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 166:12-172:9 -/
@[rust_loop]
def iter.traits.iterator.iter_find_map_loop
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B)) (iter1 : I) (f : F) :
  RustM ((option.Option B) × I)
  := do
  loop
    (fun (iter2, f1) => iter.traits.iterator.iter_find_map_loop.body
      IteratorInst coreopsfunctionFnMutFTupleClause0_ItemOptionInst iter2 f1)
    (iter1, f)

/-- [core_models::iter::traits::iterator::iter_find_map]:
    Source: 'core-models/src/core/iter.rs', lines 162:8-172:9 -/
@[reducible]
def iter.traits.iterator.iter_find_map
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B)) (iter1 : I) (f : F) :
  RustM ((option.Option B) × I)
  := do
  iter.traits.iterator.iter_find_map_loop IteratorInst
    coreopsfunctionFnMutFTupleClause0_ItemOptionInst iter1 f

/-- [core_models::iter::traits::iterator::iter_position]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 181:12-188:9 -/
@[rust_loop_body]
def iter.traits.iterator.iter_position_loop.body
  {I : Type} {P : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleClause0_ItemBoolInst : core.ops.function.FnMut P
  Clause0_Item Bool) (iter1 : I) (predicate : P) (i : Std.Usize) :
  RustM (ControlFlow (I × P × Std.Usize) ((option.Option Std.Usize) × I))
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (b, predicate1) ←
      coreopsfunctionFnMutPTupleClause0_ItemBoolInst.call_mut predicate x
    if b
    then ok (done (option.Option.Some i, iter2))
    else let i1 ← i + 1#usize
         ok (cont (iter2, predicate1, i1))
  | option.Option.None => ok (done (option.Option.None, iter2))

/-- [core_models::iter::traits::iterator::iter_position]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 181:12-188:9 -/
@[rust_loop]
def iter.traits.iterator.iter_position_loop
  {I : Type} {P : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleClause0_ItemBoolInst : core.ops.function.FnMut P
  Clause0_Item Bool) (iter1 : I) (predicate : P) (i : Std.Usize) :
  RustM ((option.Option Std.Usize) × I)
  := do
  loop
    (fun (iter2, predicate1, i1) =>
      iter.traits.iterator.iter_position_loop.body IteratorInst
      coreopsfunctionFnMutPTupleClause0_ItemBoolInst iter2 predicate1 i1)
    (iter1, predicate, i)

/-- [core_models::iter::traits::iterator::iter_position]:
    Source: 'core-models/src/core/iter.rs', lines 176:8-188:9 -/
@[reducible]
def iter.traits.iterator.iter_position
  {I : Type} {P : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleClause0_ItemBoolInst : core.ops.function.FnMut P
  Clause0_Item Bool) (iter1 : I) (predicate : P) :
  RustM ((option.Option Std.Usize) × I)
  := do
  iter.traits.iterator.iter_position_loop IteratorInst
    coreopsfunctionFnMutPTupleClause0_ItemBoolInst iter1 predicate 0#usize

/-- [core_models::iter::traits::iterator::iter_count]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 194:12-196:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_count_loop.body
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (iter1 : I) (n : Std.Usize) :
  RustM (ControlFlow (I × Std.Usize) Std.Usize)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some _ => let n1 ← n + 1#usize
                            ok (cont (iter2, n1))
  | option.Option.None => ok (done n)

/-- [core_models::iter::traits::iterator::iter_count]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 194:12-196:13 -/
@[rust_loop]
def iter.traits.iterator.iter_count_loop
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (iter1 : I) (n : Std.Usize) :
  RustM Std.Usize
  := do
  loop
    (fun (iter2, n1) => iter.traits.iterator.iter_count_loop.body IteratorInst
      iter2 n1)
    (iter1, n)

/-- [core_models::iter::traits::iterator::iter_count]:
    Source: 'core-models/src/core/iter.rs', lines 192:8-198:9 -/
@[reducible]
def iter.traits.iterator.iter_count
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (iter1 : I) :
  RustM Std.Usize
  := do
  iter.traits.iterator.iter_count_loop IteratorInst iter1 0#usize

/-- [core_models::iter::traits::iterator::iter_last]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 216:12-218:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_last_loop.body
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (iter1 : I)
  (last : option.Option Clause0_Item) :
  RustM (ControlFlow (I × (option.Option Clause0_Item)) (option.Option
    Clause0_Item))
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some _ => ok (cont (iter2, o))
  | option.Option.None => ok (done last)

/-- [core_models::iter::traits::iterator::iter_last]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 216:12-218:13 -/
@[rust_loop]
def iter.traits.iterator.iter_last_loop
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (iter1 : I)
  (last : option.Option Clause0_Item) :
  RustM (option.Option Clause0_Item)
  := do
  loop
    (fun (iter2, last1) => iter.traits.iterator.iter_last_loop.body
      IteratorInst iter2 last1)
    (iter1, last)

/-- [core_models::iter::traits::iterator::iter_last]:
    Source: 'core-models/src/core/iter.rs', lines 214:8-220:9 -/
@[reducible]
def iter.traits.iterator.iter_last
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (iter1 : I) :
  RustM (option.Option Clause0_Item)
  := do
  iter.traits.iterator.iter_last_loop IteratorInst iter1 option.Option.None

/-- [core_models::iter::traits::iterator::iter_for_each]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 225:12-227:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_for_each_loop.body
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemTupleInst : core.ops.function.FnMut F
  Clause0_Item Unit) (iter1 : I) (f : F) :
  RustM (ControlFlow (I × F) Unit)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (_, f1) ←
      coreopsfunctionFnMutFTupleClause0_ItemTupleInst.call_mut f x
    ok (cont (iter2, f1))
  | option.Option.None => ok (done ())

/-- [core_models::iter::traits::iterator::iter_for_each]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 225:12-227:13 -/
@[rust_loop]
def iter.traits.iterator.iter_for_each_loop
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemTupleInst : core.ops.function.FnMut F
  Clause0_Item Unit) (iter1 : I) (f : F) :
  RustM Unit
  := do
  loop
    (fun (iter2, f1) => iter.traits.iterator.iter_for_each_loop.body
      IteratorInst coreopsfunctionFnMutFTupleClause0_ItemTupleInst iter2 f1)
    (iter1, f)

/-- [core_models::iter::traits::iterator::iter_for_each]:
    Source: 'core-models/src/core/iter.rs', lines 224:8-228:9 -/
@[reducible]
def iter.traits.iterator.iter_for_each
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemTupleInst : core.ops.function.FnMut F
  Clause0_Item Unit) (iter1 : I) (f : F) :
  RustM Unit
  := do
  iter.traits.iterator.iter_for_each_loop IteratorInst
    coreopsfunctionFnMutFTupleClause0_ItemTupleInst iter1 f

/-- [core_models::iter::traits::iterator::iter_reduce]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 240:12-242:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_reduce_loop.body
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFPairClause0_ItemInst : core.ops.function.FnMut F
  (Clause0_Item × Clause0_Item) Clause0_Item) (iter1 : I) (f : F)
  (accum : Clause0_Item) :
  RustM (ControlFlow (I × F × Clause0_Item) Clause0_Item)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let (accum1, f1) ←
      coreopsfunctionFnMutFPairClause0_ItemInst.call_mut f (accum, x)
    ok (cont (iter2, f1, accum1))
  | option.Option.None => ok (done accum)

/-- [core_models::iter::traits::iterator::iter_reduce]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 240:12-242:13 -/
@[rust_loop]
def iter.traits.iterator.iter_reduce_loop
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFPairClause0_ItemInst : core.ops.function.FnMut F
  (Clause0_Item × Clause0_Item) Clause0_Item) (iter1 : I) (f : F)
  (accum : Clause0_Item) :
  RustM Clause0_Item
  := do
  loop
    (fun (iter2, f1, accum1) => iter.traits.iterator.iter_reduce_loop.body
      IteratorInst coreopsfunctionFnMutFPairClause0_ItemInst iter2 f1 accum1)
    (iter1, f, accum)

/-- [core_models::iter::traits::iterator::iter_reduce]:
    Source: 'core-models/src/core/iter.rs', lines 232:8-244:9 -/
def iter.traits.iterator.iter_reduce
  {I : Type} {F : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFPairClause0_ItemInst : core.ops.function.FnMut F
  (Clause0_Item × Clause0_Item) Clause0_Item) (iter1 : I) (f : F) :
  RustM (option.Option Clause0_Item)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let accum ←
      iter.traits.iterator.iter_reduce_loop IteratorInst
        coreopsfunctionFnMutFPairClause0_ItemInst iter2 f x
    ok (option.Option.Some accum)
  | option.Option.None => ok option.Option.None

/-- [core_models::iter::traits::iterator::iter_min]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 256:12-260:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_min_loop.body
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (cmpOrdInst : cmp.Ord
  Clause0_Item) (iter1 : I) (min : Clause0_Item) :
  RustM (ControlFlow (I × Clause0_Item) Clause0_Item)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let o1 ← cmpOrdInst.cmp x min
    match o1 with
    | cmp.Ordering.Less => ok (cont (iter2, x))
    | cmp.Ordering.Equal => ok (cont (iter2, min))
    | cmp.Ordering.Greater => ok (cont (iter2, min))
  | option.Option.None => ok (done min)

/-- [core_models::iter::traits::iterator::iter_min]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 256:12-260:13 -/
@[rust_loop]
def iter.traits.iterator.iter_min_loop
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (cmpOrdInst : cmp.Ord
  Clause0_Item) (iter1 : I) (min : Clause0_Item) :
  RustM Clause0_Item
  := do
  loop
    (fun (iter2, min1) => iter.traits.iterator.iter_min_loop.body IteratorInst
      cmpOrdInst iter2 min1)
    (iter1, min)

/-- [core_models::iter::traits::iterator::iter_min]:
    Source: 'core-models/src/core/iter.rs', lines 248:8-262:9 -/
def iter.traits.iterator.iter_min
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (cmpOrdInst : cmp.Ord
  Clause0_Item) (iter1 : I) :
  RustM (option.Option Clause0_Item)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let min ←
      iter.traits.iterator.iter_min_loop IteratorInst cmpOrdInst iter2 x
    ok (option.Option.Some min)
  | option.Option.None => ok option.Option.None

/-- [core_models::iter::traits::iterator::iter_max]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 274:12-280:13 -/
@[rust_loop_body]
def iter.traits.iterator.iter_max_loop.body
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (cmpOrdInst : cmp.Ord
  Clause0_Item) (iter1 : I) (max : Clause0_Item) :
  RustM (ControlFlow (I × Clause0_Item) Clause0_Item)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let o1 ← cmpOrdInst.cmp x max
    match o1 with
    | cmp.Ordering.Less => ok (cont (iter2, max))
    | cmp.Ordering.Equal => ok (cont (iter2, x))
    | cmp.Ordering.Greater => ok (cont (iter2, x))
  | option.Option.None => ok (done max)

/-- [core_models::iter::traits::iterator::iter_max]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 274:12-280:13 -/
@[rust_loop]
def iter.traits.iterator.iter_max_loop
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (cmpOrdInst : cmp.Ord
  Clause0_Item) (iter1 : I) (max : Clause0_Item) :
  RustM Clause0_Item
  := do
  loop
    (fun (iter2, max1) => iter.traits.iterator.iter_max_loop.body IteratorInst
      cmpOrdInst iter2 max1)
    (iter1, max)

/-- [core_models::iter::traits::iterator::iter_max]:
    Source: 'core-models/src/core/iter.rs', lines 266:8-282:9 -/
def iter.traits.iterator.iter_max
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (cmpOrdInst : cmp.Ord
  Clause0_Item) (iter1 : I) :
  RustM (option.Option Clause0_Item)
  := do
  let (o, iter2) ← IteratorInst.next iter1
  match o with
  | option.Option.Some x =>
    let max ←
      iter.traits.iterator.iter_max_loop IteratorInst cmpOrdInst iter2 x
    ok (option.Option.Some max)
  | option.Option.None => ok option.Option.None

/-- [core_models::iter::traits::iterator::{impl core_models::iter::traits::collect::IntoIterator<Clause0_Item, I> for I}::into_iter]:
    Source: 'core-models/src/core/iter.rs', lines 425:12-427:13
    Visibility: public -/
def iter.traits.collect.IntoIterator.Blanket.into_iter
  {I : Type} {Clause0_Item : Type} (IteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) (self : I) :
  RustM I
  := do
  ok self

/-- Trait implementation: [core_models::iter::traits::iterator::{impl core_models::iter::traits::collect::IntoIterator<Clause0_Item, I> for I}]
    Source: 'core-models/src/core/iter.rs', lines 422:8-428:9 -/
@[reducible]
def iter.traits.collect.IntoIterator.Blanket {I : Type} {Clause0_Item : Type}
  (IteratorInst : iter.traits.iterator.Iterator I Clause0_Item) :
  iter.traits.collect.IntoIterator I Clause0_Item I := {
  iteratorIteratorInst := IteratorInst
  into_iter := iter.traits.collect.IntoIterator.Blanket.into_iter IteratorInst
}

/-- [core_models::iter::adapters::enumerate::{core_models::iter::adapters::enumerate::Enumerate<I>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 495:12-497:13
    Visibility: public -/
def iter.adapters.enumerate.Enumerate.new
  {I : Type} (iter1 : I) : RustM (iter.adapters.enumerate.Enumerate I) := do
  ok { iter := iter1, count := 0#usize }

/-- [core_models::iter::adapters::enumerate::{impl core_models::iter::traits::iterator::Iterator<(usize, Clause0_Item)> for core_models::iter::adapters::enumerate::Enumerate<I>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 503:12-517:13
    Visibility: public -/
def
  iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsIteratorIteratorPairUsizeClause0_Item.next
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.enumerate.Enumerate I) :
  RustM ((option.Option (Std.Usize × Clause0_Item)) ×
    (iter.adapters.enumerate.Enumerate I))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some a =>
    let i ← self.count + 1#usize
    ok (option.Option.Some (self.count, a), { iter := t, count := i })
  | option.Option.None => ok (option.Option.None, { self with iter := t })

/-- Trait implementation: [core_models::iter::adapters::enumerate::{impl core_models::iter::traits::iterator::Iterator<(usize, Clause0_Item)> for core_models::iter::adapters::enumerate::Enumerate<I>}]
    Source: 'core-models/src/core/iter.rs', lines 500:8-518:9 -/
@[reducible]
def
  iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsIteratorIteratorPairUsizeClause0_Item
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) : iter.traits.iterator.Iterator
  (iter.adapters.enumerate.Enumerate I) (Std.Usize × Clause0_Item) := {
  next :=
    iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsIteratorIteratorPairUsizeClause0_Item.next
    traitsiteratorIteratorInst
}

/-- [core_models::iter::adapters::enumerate::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<(usize, Clause0_Clause0_Item)> for core_models::iter::adapters::enumerate::Enumerate<I>}::next_back]:
    Source: 'core-models/src/core/iter.rs', lines 534:12-545:13
    Visibility: public -/
def
  iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorPairUsizeClause0_Clause0_Item.next_back
  {I : Type} {Clause0_Clause0_Item : Type} {Clause1_Clause0_Item : Type}
  (traitsdouble_endedDoubleEndedIteratorInst :
  iter.traits.double_ended.DoubleEndedIterator I Clause0_Clause0_Item)
  (traitsexact_sizeExactSizeIteratorInst :
  iter.traits.exact_size.ExactSizeIterator I Clause1_Clause0_Item)
  (self : iter.adapters.enumerate.Enumerate I) :
  RustM ((option.Option (Std.Usize × Clause0_Clause0_Item)) ×
    (iter.adapters.enumerate.Enumerate I))
  := do
  let (o, t) ← traitsdouble_endedDoubleEndedIteratorInst.next_back self.iter
  match o with
  | option.Option.Some a =>
    let len ← traitsexact_sizeExactSizeIteratorInst.len t
    let i ← self.count + len
    ok (option.Option.Some (i, a), { self with iter := t })
  | option.Option.None => ok (option.Option.None, { self with iter := t })

/-- Trait implementation: [core_models::iter::adapters::enumerate::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<(usize, Clause0_Clause0_Item)> for core_models::iter::adapters::enumerate::Enumerate<I>}]
    Source: 'core-models/src/core/iter.rs', lines 529:8-546:9 -/
@[reducible]
def
  iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorPairUsizeClause0_Clause0_Item
  {I : Type} {Clause0_Clause0_Item : Type} {Clause1_Clause0_Item : Type}
  (traitsdouble_endedDoubleEndedIteratorInst :
  iter.traits.double_ended.DoubleEndedIterator I Clause0_Clause0_Item)
  (traitsexact_sizeExactSizeIteratorInst :
  iter.traits.exact_size.ExactSizeIterator I Clause1_Clause0_Item) :
  iter.traits.double_ended.DoubleEndedIterator
  (iter.adapters.enumerate.Enumerate I) (Std.Usize × Clause0_Clause0_Item)
  := {
  iteratorIteratorInst :=
    iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsIteratorIteratorPairUsizeClause0_Item
    traitsdouble_endedDoubleEndedIteratorInst.iteratorIteratorInst
  next_back :=
    iter.adapters.enumerate.Enumerate.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorPairUsizeClause0_Clause0_Item.next_back
    traitsdouble_endedDoubleEndedIteratorInst
    traitsexact_sizeExactSizeIteratorInst
}

/-- [core_models::iter::adapters::rev::{core_models::iter::adapters::rev::Rev<I>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 563:12-565:13
    Visibility: public -/
def iter.adapters.rev.Rev.new
  {I : Type} (iter1 : I) : RustM (iter.adapters.rev.Rev I) := do
  ok { iter := iter1 }

/-- [core_models::iter::adapters::rev::{impl core_models::iter::traits::iterator::Iterator<Clause0_Clause0_Item> for core_models::iter::adapters::rev::Rev<I>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 571:12-573:13
    Visibility: public -/
def iter.adapters.rev.Rev.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {Clause0_Clause0_Item : Type}
  (traitsdouble_endedDoubleEndedIteratorInst :
  iter.traits.double_ended.DoubleEndedIterator I Clause0_Clause0_Item)
  (self : iter.adapters.rev.Rev I) :
  RustM ((option.Option Clause0_Clause0_Item) × (iter.adapters.rev.Rev I))
  := do
  let (o, t) ← traitsdouble_endedDoubleEndedIteratorInst.next_back self.iter
  ok (o, { iter := t })

/-- Trait implementation: [core_models::iter::adapters::rev::{impl core_models::iter::traits::iterator::Iterator<Clause0_Clause0_Item> for core_models::iter::adapters::rev::Rev<I>}]
    Source: 'core-models/src/core/iter.rs', lines 569:8-574:9 -/
@[reducible]
def iter.adapters.rev.Rev.Insts.CoreIterTraitsIteratorIterator {I :
  Type} {Clause0_Clause0_Item : Type}
  (traitsdouble_endedDoubleEndedIteratorInst :
  iter.traits.double_ended.DoubleEndedIterator I Clause0_Clause0_Item) :
  iter.traits.iterator.Iterator (iter.adapters.rev.Rev I) Clause0_Clause0_Item
  := {
  next :=
    iter.adapters.rev.Rev.Insts.CoreIterTraitsIteratorIterator.next
    traitsdouble_endedDoubleEndedIteratorInst
}

/-- [core_models::iter::adapters::step_by::{core_models::iter::adapters::step_by::StepBy<I>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 589:12-594:13
    Visibility: public -/
def iter.adapters.step_by.StepBy.new
  {I : Type} (iter1 : I) (step : Std.Usize) :
  RustM (iter.adapters.step_by.StepBy I)
  := do
  if step = 0#usize
  then panicking.internal.panic Unit
       ok { iter := iter1, step }
  else ok { iter := iter1, step }









/-- [core_models::iter::adapters::map::{core_models::iter::adapters::map::Map<I, F>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 623:12-625:13
    Visibility: public -/
def iter.adapters.map.Map.new
  {I : Type} {F : Type} (iter1 : I) (f : F) :
  RustM (iter.adapters.map.Map I F)
  := do
  ok { iter := iter1, f }

/-- [core_models::iter::adapters::map::{impl core_models::iter::traits::iterator::Iterator<O> for core_models::iter::adapters::map::Map<I, F>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 637:12-642:13
    Visibility: public -/
def iter.adapters.map.Map.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {O : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOInst : core.ops.function.FnMut F
  Clause0_Item O) (self : iter.adapters.map.Map I F) :
  RustM ((option.Option O) × (iter.adapters.map.Map I F))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some v =>
    let (t1, t2) ←
      coreopsfunctionFnMutFTupleClause0_ItemOInst.call_mut self.f v
    ok (option.Option.Some t1, { iter := t, f := t2 })
  | option.Option.None => ok (option.Option.None, { self with iter := t })

/-- Trait implementation: [core_models::iter::adapters::map::{impl core_models::iter::traits::iterator::Iterator<O> for core_models::iter::adapters::map::Map<I, F>}]
    Source: 'core-models/src/core/iter.rs', lines 634:8-643:9 -/
@[reducible]
def iter.adapters.map.Map.Insts.CoreIterTraitsIteratorIterator {I :
  Type} {O : Type} {F : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst
  : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOInst : core.ops.function.FnMut F
  Clause0_Item O) : iter.traits.iterator.Iterator (iter.adapters.map.Map I F) O
  := {
  next :=
    iter.adapters.map.Map.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst coreopsfunctionFnMutFTupleClause0_ItemOInst
}

/-- [core_models::iter::adapters::take::{core_models::iter::adapters::take::Take<I>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 655:12-657:13
    Visibility: public -/
def iter.adapters.take.Take.new
  {I : Type} (iter1 : I) (n : Std.Usize) :
  RustM (iter.adapters.take.Take I)
  := do
  ok { iter := iter1, n }

/-- [core_models::iter::adapters::take::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::take::Take<I>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 663:12-670:13
    Visibility: public -/
def iter.adapters.take.Take.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.take.Take I) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.take.Take I))
  := do
  if self.n != 0#usize
  then
    let i ← self.n - 1#usize
    let (o, t) ← traitsiteratorIteratorInst.next self.iter
    ok (o, { iter := t, n := i })
  else ok (option.Option.None, self)

/-- Trait implementation: [core_models::iter::adapters::take::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::take::Take<I>}]
    Source: 'core-models/src/core/iter.rs', lines 660:8-671:9 -/
@[reducible]
def iter.adapters.take.Take.Insts.CoreIterTraitsIteratorIterator {I :
  Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) : iter.traits.iterator.Iterator
  (iter.adapters.take.Take I) Clause0_Item := {
  next :=
    iter.adapters.take.Take.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
}

/-- [core_models::iter::adapters::flat_map::{core_models::iter::adapters::flat_map::FlatMap<I, U, F>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 684:12-690:13
    Visibility: public -/
def iter.adapters.flat_map.FlatMap.new
  {I : Type} {U : Type} {F : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator U Clause1_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemUInst : core.ops.function.FnMut F
  Clause0_Item U) (it : I) (f : F) :
  RustM (iter.adapters.flat_map.FlatMap I U F)
  := do
  ok { it, f, current := option.Option.None }

/-- [core_models::iter::adapters::flat_map::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flat_map::FlatMap<I, U, F>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 698:20-709:13
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {U : Type} {F : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator U Clause1_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemUInst : core.ops.function.FnMut F
  Clause0_Item U) (self : iter.adapters.flat_map.FlatMap I U F) :
  RustM (ControlFlow (iter.adapters.flat_map.FlatMap I U F) ((option.Option
    Clause1_Item) × I × F × (option.Option U)))
  := do
  match self.current with
  | option.Option.Some current_it =>
    let (o, current_it1) ← traitsiteratorIteratorInst1.next current_it
    match o with
    | option.Option.Some _ =>
      ok (done (o, self.it, self.f, option.Option.Some current_it1))
    | option.Option.None =>
      let (o1, t) ← traitsiteratorIteratorInst.next self.it
      match o1 with
      | option.Option.Some c =>
        let (t1, t2) ←
          coreopsfunctionFnMutFTupleClause0_ItemUInst.call_mut self.f c
        ok (cont { it := t, f := t2, current := (option.Option.Some t1) })
      | option.Option.None =>
        ok (done (option.Option.None, t, self.f, option.Option.Some
          current_it1))
  | option.Option.None =>
    let (o, t) ← traitsiteratorIteratorInst.next self.it
    match o with
    | option.Option.Some c =>
      let (t1, t2) ←
        coreopsfunctionFnMutFTupleClause0_ItemUInst.call_mut self.f c
      ok (cont { it := t, f := t2, current := (option.Option.Some t1) })
    | option.Option.None =>
      ok (done (option.Option.None, t, self.f, option.Option.None))

/-- [core_models::iter::adapters::flat_map::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flat_map::FlatMap<I, U, F>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 698:20-709:13
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {U : Type} {F : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator U Clause1_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemUInst : core.ops.function.FnMut F
  Clause0_Item U) (self : iter.adapters.flat_map.FlatMap I U F) :
  RustM ((option.Option Clause1_Item) × I × F × (option.Option U))
  := do
  loop
    (fun self1 =>
      iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst traitsiteratorIteratorInst1
      coreopsfunctionFnMutFTupleClause0_ItemUInst self1)
    self

/-- [core_models::iter::adapters::flat_map::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flat_map::FlatMap<I, U, F>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 696:12-709:13
    Visibility: public -/
def
  iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {U : Type} {F : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator U Clause1_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemUInst : core.ops.function.FnMut F
  Clause0_Item U) (self : iter.adapters.flat_map.FlatMap I U F) :
  RustM ((option.Option Clause1_Item) × (iter.adapters.flat_map.FlatMap I U
    F))
  := do
  let (o, t, t1, o1) ←
    iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst traitsiteratorIteratorInst1
      coreopsfunctionFnMutFTupleClause0_ItemUInst self
  ok (o, { it := t, f := t1, current := o1 })

/-- Trait implementation: [core_models::iter::adapters::flat_map::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flat_map::FlatMap<I, U, F>}]
    Source: 'core-models/src/core/iter.rs', lines 694:8-710:9 -/
@[reducible]
def iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {U : Type} {F : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator U Clause1_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemUInst : core.ops.function.FnMut F
  Clause0_Item U) : iter.traits.iterator.Iterator
  (iter.adapters.flat_map.FlatMap I U F) Clause1_Item := {
  next :=
    iter.adapters.flat_map.FlatMap.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst traitsiteratorIteratorInst1
    coreopsfunctionFnMutFTupleClause0_ItemUInst
}

/-- [core_models::iter::adapters::flatten::{core_models::iter::adapters::flatten::Flatten<I, Clause0_Item, Clause1_Item>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 729:12-734:13
    Visibility: public -/
def iter.adapters.flatten.Flatten.new
  {I : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator Clause0_Item
  Clause1_Item) (it : I) :
  RustM (iter.adapters.flatten.Flatten I Clause0_Item Clause1_Item)
  := do
  ok { it, current := option.Option.None }

/-- [core_models::iter::adapters::flatten::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flatten::Flatten<I, Clause0_Item, Clause1_Item>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 745:20-756:13
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator Clause0_Item
  Clause1_Item)
  (self : iter.adapters.flatten.Flatten I Clause0_Item Clause1_Item) :
  RustM (ControlFlow (iter.adapters.flatten.Flatten I Clause0_Item
    Clause1_Item) ((option.Option Clause1_Item) × I × (option.Option
    Clause0_Item)))
  := do
  match self.current with
  | option.Option.Some current_it =>
    let (o, current_it1) ← traitsiteratorIteratorInst1.next current_it
    match o with
    | option.Option.Some _ =>
      ok (done (o, self.it, option.Option.Some current_it1))
    | option.Option.None =>
      let (o1, t) ← traitsiteratorIteratorInst.next self.it
      match o1 with
      | option.Option.Some _ => ok (cont { it := t, current := o1 })
      | option.Option.None =>
        ok (done (option.Option.None, t, option.Option.Some current_it1))
  | option.Option.None =>
    let (o, t) ← traitsiteratorIteratorInst.next self.it
    match o with
    | option.Option.Some _ => ok (cont { it := t, current := o })
    | option.Option.None =>
      ok (done (option.Option.None, t, option.Option.None))

/-- [core_models::iter::adapters::flatten::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flatten::Flatten<I, Clause0_Item, Clause1_Item>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 745:20-756:13
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator Clause0_Item
  Clause1_Item)
  (self : iter.adapters.flatten.Flatten I Clause0_Item Clause1_Item) :
  RustM ((option.Option Clause1_Item) × I × (option.Option Clause0_Item))
  := do
  loop
    (fun self1 =>
      iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst traitsiteratorIteratorInst1 self1)
    self

/-- [core_models::iter::adapters::flatten::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flatten::Flatten<I, Clause0_Item, Clause1_Item>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 743:12-756:13
    Visibility: public -/
def
  iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator Clause0_Item
  Clause1_Item)
  (self : iter.adapters.flatten.Flatten I Clause0_Item Clause1_Item) :
  RustM ((option.Option Clause1_Item) × (iter.adapters.flatten.Flatten I
    Clause0_Item Clause1_Item))
  := do
  let (o, t, o1) ←
    iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst traitsiteratorIteratorInst1 self
  ok (o, { it := t, current := o1 })

/-- Trait implementation: [core_models::iter::adapters::flatten::{impl core_models::iter::traits::iterator::Iterator<Clause1_Item> for core_models::iter::adapters::flatten::Flatten<I, Clause0_Item, Clause1_Item>}]
    Source: 'core-models/src/core/iter.rs', lines 738:8-757:9 -/
@[reducible]
def iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator Clause0_Item
  Clause1_Item) : iter.traits.iterator.Iterator (iter.adapters.flatten.Flatten
  I Clause0_Item Clause1_Item) Clause1_Item := {
  next :=
    iter.adapters.flatten.Flatten.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst traitsiteratorIteratorInst1
}

/-- [core_models::iter::adapters::zip::{core_models::iter::adapters::zip::Zip<I1, I2>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 769:12-771:13
    Visibility: public -/
def iter.adapters.zip.Zip.new
  {I1 : Type} {I2 : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I1 Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator I2 Clause1_Item)
  (it1 : I1) (it2 : I2) :
  RustM (iter.adapters.zip.Zip I1 I2)
  := do
  ok { it1, it2 }

/-- [core_models::iter::adapters::zip::{impl core_models::iter::traits::iterator::Iterator<(Clause0_Item, Clause1_Item)> for core_models::iter::adapters::zip::Zip<I1, I2>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 777:12-785:13
    Visibility: public -/
def iter.adapters.zip.Zip.Insts.CoreIterTraitsIteratorIteratorPair.next
  {I1 : Type} {I2 : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I1 Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator I2 Clause1_Item)
  (self : iter.adapters.zip.Zip I1 I2) :
  RustM ((option.Option (Clause0_Item × Clause1_Item)) ×
    (iter.adapters.zip.Zip I1 I2))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.it1
  match o with
  | option.Option.Some v1 =>
    let (o1, t1) ← traitsiteratorIteratorInst1.next self.it2
    match o1 with
    | option.Option.Some v2 =>
      ok (option.Option.Some (v1, v2), { it1 := t, it2 := t1 })
    | option.Option.None => ok (option.Option.None, { it1 := t, it2 := t1 })
  | option.Option.None => ok (option.Option.None, { self with it1 := t })

/-- Trait implementation: [core_models::iter::adapters::zip::{impl core_models::iter::traits::iterator::Iterator<(Clause0_Item, Clause1_Item)> for core_models::iter::adapters::zip::Zip<I1, I2>}]
    Source: 'core-models/src/core/iter.rs', lines 775:8-786:9 -/
@[reducible]
def iter.adapters.zip.Zip.Insts.CoreIterTraitsIteratorIteratorPair {I1 :
  Type} {I2 : Type} {Clause0_Item : Type} {Clause1_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I1 Clause0_Item)
  (traitsiteratorIteratorInst1 : iter.traits.iterator.Iterator I2 Clause1_Item)
  : iter.traits.iterator.Iterator (iter.adapters.zip.Zip I1 I2) (Clause0_Item
  × Clause1_Item) := {
  next :=
    iter.adapters.zip.Zip.Insts.CoreIterTraitsIteratorIteratorPair.next
    traitsiteratorIteratorInst traitsiteratorIteratorInst1
}

/-- [core_models::iter::adapters::filter::{core_models::iter::adapters::filter::Filter<I, P>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 798:12-800:13
    Visibility: public -/
def iter.adapters.filter.Filter.new
  {I : Type} {P : Type} (iter1 : I) (predicate : P) :
  RustM (iter.adapters.filter.Filter I P)
  := do
  ok { iter := iter1, predicate }

/-- [core_models::iter::adapters::filter::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::filter::Filter<I, P>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 811:16-820:17
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.filter.Filter I P) :
  RustM (ControlFlow (iter.adapters.filter.Filter I P) ((option.Option
    Clause0_Item) × I × P))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some v =>
    let (b, t1) ←
      coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst.call_mut
        self.predicate v
    if b
    then ok (done (o, t, t1))
    else ok (cont { iter := t, predicate := t1 })
  | option.Option.None => ok (done (option.Option.None, t, self.predicate))

/-- [core_models::iter::adapters::filter::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::filter::Filter<I, P>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 811:16-820:17
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.filter.Filter I P) :
  RustM ((option.Option Clause0_Item) × I × P)
  := do
  loop
    (fun self1 =>
      iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst
      coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst self1)
    self

/-- [core_models::iter::adapters::filter::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::filter::Filter<I, P>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 810:12-821:13
    Visibility: public -/
def
  iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.filter.Filter I P) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.filter.Filter I P))
  := do
  let (o, t, t1) ←
    iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst
      coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst self
  ok (o, { iter := t, predicate := t1 })

/-- Trait implementation: [core_models::iter::adapters::filter::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::filter::Filter<I, P>}]
    Source: 'core-models/src/core/iter.rs', lines 808:8-822:9 -/
@[reducible]
def iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator {I
  : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool) : iter.traits.iterator.Iterator
  (iter.adapters.filter.Filter I P) Clause0_Item := {
  next :=
    iter.adapters.filter.Filter.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
    coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst
}

/-- [core_models::iter::adapters::chain::{core_models::iter::adapters::chain::Chain<A, B>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 834:12-839:13
    Visibility: public -/
def iter.adapters.chain.Chain.new
  {A : Type} {B : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator A Clause0_Item) (traitsiteratorIteratorInst1 :
  iter.traits.iterator.Iterator B Clause0_Item) (a : A) (b : B) :
  RustM (iter.adapters.chain.Chain A B)
  := do
  ok { a := (option.Option.Some a), b }

/-- [core_models::iter::adapters::chain::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::chain::Chain<A, B>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 846:12-854:13
    Visibility: public -/
def iter.adapters.chain.Chain.Insts.CoreIterTraitsIteratorIterator.next
  {A : Type} {B : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator A Clause0_Item) (traitsiteratorIteratorInst1 :
  iter.traits.iterator.Iterator B Clause0_Item)
  (self : iter.adapters.chain.Chain A B) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.chain.Chain A B))
  := do
  match self.a with
  | option.Option.Some a =>
    let (o, a1) ← traitsiteratorIteratorInst.next a
    match o with
    | option.Option.Some _ =>
      ok (o, { self with a := (option.Option.Some a1) })
    | option.Option.None =>
      let (o1, t) ← traitsiteratorIteratorInst1.next self.b
      ok (o1, { a := option.Option.None, b := t })
  | option.Option.None =>
    let (o, t) ← traitsiteratorIteratorInst1.next self.b
    ok (o, { a := option.Option.None, b := t })

/-- Trait implementation: [core_models::iter::adapters::chain::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::chain::Chain<A, B>}]
    Source: 'core-models/src/core/iter.rs', lines 844:8-855:9 -/
@[reducible]
def iter.adapters.chain.Chain.Insts.CoreIterTraitsIteratorIterator {A :
  Type} {B : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator A Clause0_Item) (traitsiteratorIteratorInst1 :
  iter.traits.iterator.Iterator B Clause0_Item) : iter.traits.iterator.Iterator
  (iter.adapters.chain.Chain A B) Clause0_Item := {
  next :=
    iter.adapters.chain.Chain.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst traitsiteratorIteratorInst1
}

/-- [core_models::iter::adapters::skip::{core_models::iter::adapters::skip::Skip<I>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 867:12-869:13
    Visibility: public -/
def iter.adapters.skip.Skip.new
  {I : Type} (iter1 : I) (n : Std.Usize) :
  RustM (iter.adapters.skip.Skip I)
  := do
  ok { iter := iter1, n }

/-- [core_models::iter::adapters::skip::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip::Skip<I>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 877:16-884:13
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.skip.Skip I) :
  RustM (ControlFlow (iter.adapters.skip.Skip I) ((option.Option Clause0_Item)
    × I × Std.Usize))
  := do
  if self.n > 0#usize
  then
    let i ← self.n - 1#usize
    let (o, t) ← traitsiteratorIteratorInst.next self.iter
    match o with
    | option.Option.Some _ => ok (cont { iter := t, n := i })
    | option.Option.None => ok (done (option.Option.None, t, i))
  else
    let (o, t) ← traitsiteratorIteratorInst.next self.iter
    ok (done (o, t, self.n))

/-- [core_models::iter::adapters::skip::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip::Skip<I>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 877:16-884:13
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.skip.Skip I) :
  RustM ((option.Option Clause0_Item) × I × Std.Usize)
  := do
  loop
    (fun self1 =>
      iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst self1)
    self

/-- [core_models::iter::adapters::skip::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip::Skip<I>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 876:12-884:13
    Visibility: public -/
def iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.skip.Skip I) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.skip.Skip I))
  := do
  let (o, t, i) ←
    iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst self
  ok (o, { iter := t, n := i })

/-- Trait implementation: [core_models::iter::adapters::skip::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip::Skip<I>}]
    Source: 'core-models/src/core/iter.rs', lines 874:8-885:9 -/
@[reducible]
def iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator {I :
  Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) : iter.traits.iterator.Iterator
  (iter.adapters.skip.Skip I) Clause0_Item := {
  next :=
    iter.adapters.skip.Skip.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
}

/-- [core_models::iter::adapters::filter_map::{core_models::iter::adapters::filter_map::FilterMap<I, F>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 896:12-898:13
    Visibility: public -/
def iter.adapters.filter_map.FilterMap.new
  {I : Type} {F : Type} (iter1 : I) (f : F) :
  RustM (iter.adapters.filter_map.FilterMap I F)
  := do
  ok { iter := iter1, f }

/-- [core_models::iter::adapters::filter_map::{impl core_models::iter::traits::iterator::Iterator<B> for core_models::iter::adapters::filter_map::FilterMap<I, F>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 905:16-914:17
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B))
  (self : iter.adapters.filter_map.FilterMap I F) :
  RustM (ControlFlow (iter.adapters.filter_map.FilterMap I F) ((option.Option
    B) × I × F))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some x =>
    let (o1, t1) ←
      coreopsfunctionFnMutFTupleClause0_ItemOptionInst.call_mut self.f x
    match o1 with
    | option.Option.Some _ => ok (done (o1, t, t1))
    | option.Option.None => ok (cont { iter := t, f := t1 })
  | option.Option.None => ok (done (option.Option.None, t, self.f))

/-- [core_models::iter::adapters::filter_map::{impl core_models::iter::traits::iterator::Iterator<B> for core_models::iter::adapters::filter_map::FilterMap<I, F>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 905:16-914:17
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B))
  (self : iter.adapters.filter_map.FilterMap I F) :
  RustM ((option.Option B) × I × F)
  := do
  loop
    (fun self1 =>
      iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst
      coreopsfunctionFnMutFTupleClause0_ItemOptionInst self1)
    self

/-- [core_models::iter::adapters::filter_map::{impl core_models::iter::traits::iterator::Iterator<B> for core_models::iter::adapters::filter_map::FilterMap<I, F>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 904:12-915:13
    Visibility: public -/
def
  iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B))
  (self : iter.adapters.filter_map.FilterMap I F) :
  RustM ((option.Option B) × (iter.adapters.filter_map.FilterMap I F))
  := do
  let (o, t, t1) ←
    iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst
      coreopsfunctionFnMutFTupleClause0_ItemOptionInst self
  ok (o, { iter := t, f := t1 })

/-- Trait implementation: [core_models::iter::adapters::filter_map::{impl core_models::iter::traits::iterator::Iterator<B> for core_models::iter::adapters::filter_map::FilterMap<I, F>}]
    Source: 'core-models/src/core/iter.rs', lines 902:8-916:9 -/
@[reducible]
def
  iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B)) : iter.traits.iterator.Iterator
  (iter.adapters.filter_map.FilterMap I F) B := {
  next :=
    iter.adapters.filter_map.FilterMap.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst coreopsfunctionFnMutFTupleClause0_ItemOptionInst
}

/-- [core_models::iter::adapters::take_while::{core_models::iter::adapters::take_while::TakeWhile<I, P>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 928:12-934:13
    Visibility: public -/
def iter.adapters.take_while.TakeWhile.new
  {I : Type} {P : Type} (iter1 : I) (predicate : P) :
  RustM (iter.adapters.take_while.TakeWhile I P)
  := do
  ok { iter := iter1, flag := false, predicate }

/-- [core_models::iter::adapters::take_while::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::take_while::TakeWhile<I, P>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 939:12-955:13
    Visibility: public -/
def
  iter.adapters.take_while.TakeWhile.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.take_while.TakeWhile I P) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.take_while.TakeWhile I
    P))
  := do
  if self.flag
  then ok (option.Option.None, self)
  else
    let (o, t) ← traitsiteratorIteratorInst.next self.iter
    match o with
    | option.Option.Some x =>
      let (b, t1) ←
        coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst.call_mut
          self.predicate x
      if b
      then ok (o, { iter := t, flag := false, predicate := t1 })
      else
        ok (option.Option.None, { iter := t, flag := true, predicate := t1 })
    | option.Option.None => ok (option.Option.None, { self with iter := t })

/-- Trait implementation: [core_models::iter::adapters::take_while::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::take_while::TakeWhile<I, P>}]
    Source: 'core-models/src/core/iter.rs', lines 937:8-956:9 -/
@[reducible]
def
  iter.adapters.take_while.TakeWhile.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool) : iter.traits.iterator.Iterator
  (iter.adapters.take_while.TakeWhile I P) Clause0_Item := {
  next :=
    iter.adapters.take_while.TakeWhile.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
    coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst
}

/-- [core_models::iter::adapters::skip_while::{core_models::iter::adapters::skip_while::SkipWhile<I, P>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 968:12-974:13
    Visibility: public -/
def iter.adapters.skip_while.SkipWhile.new
  {I : Type} {P : Type} (iter1 : I) (predicate : P) :
  RustM (iter.adapters.skip_while.SkipWhile I P)
  := do
  ok { iter := iter1, flag := false, predicate }

/-- [core_models::iter::adapters::skip_while::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip_while::SkipWhile<I, P>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 981:16-991:17
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.skip_while.SkipWhile I P) :
  RustM (ControlFlow (iter.adapters.skip_while.SkipWhile I P) ((option.Option
    Clause0_Item) × I × Bool × P))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some x =>
    if self.flag
    then ok (done (o, t, true, self.predicate))
    else
      let (b, t1) ←
        coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst.call_mut
          self.predicate x
      if b
      then ok (cont { iter := t, flag := false, predicate := t1 })
      else ok (done (o, t, true, t1))
  | option.Option.None =>
    ok (done (option.Option.None, t, self.flag, self.predicate))

/-- [core_models::iter::adapters::skip_while::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip_while::SkipWhile<I, P>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 981:16-991:17
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.skip_while.SkipWhile I P) :
  RustM ((option.Option Clause0_Item) × I × Bool × P)
  := do
  loop
    (fun self1 =>
      iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst
      coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst self1)
    self

/-- [core_models::iter::adapters::skip_while::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip_while::SkipWhile<I, P>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 980:12-992:13
    Visibility: public -/
def
  iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool)
  (self : iter.adapters.skip_while.SkipWhile I P) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.skip_while.SkipWhile I
    P))
  := do
  let (o, t, b, t1) ←
    iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst
      coreopsfunctionFnMutPTupleShared0Clause0_ItemBoolInst self
  ok (o, { iter := t, flag := b, predicate := t1 })

/-- Trait implementation: [core_models::iter::adapters::skip_while::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::skip_while::SkipWhile<I, P>}]
    Source: 'core-models/src/core/iter.rs', lines 978:8-993:9 -/
@[reducible]
def
  iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {P : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst :
  core.ops.function.FnMut P Clause0_Item Bool) : iter.traits.iterator.Iterator
  (iter.adapters.skip_while.SkipWhile I P) Clause0_Item := {
  next :=
    iter.adapters.skip_while.SkipWhile.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
    coreopsfunctionFnMutPTupleSharedClause0_ItemBoolInst
}

/-- [core_models::iter::adapters::map_while::{core_models::iter::adapters::map_while::MapWhile<I, F>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 1004:12-1006:13
    Visibility: public -/
def iter.adapters.map_while.MapWhile.new
  {I : Type} {F : Type} (iter1 : I) (f : F) :
  RustM (iter.adapters.map_while.MapWhile I F)
  := do
  ok { iter := iter1, f }

/-- [core_models::iter::adapters::map_while::{impl core_models::iter::traits::iterator::Iterator<B> for core_models::iter::adapters::map_while::MapWhile<I, F>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 1011:12-1016:13
    Visibility: public -/
def
  iter.adapters.map_while.MapWhile.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B)) (self : iter.adapters.map_while.MapWhile I F)
  :
  RustM ((option.Option B) × (iter.adapters.map_while.MapWhile I F))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some x =>
    let (o1, t1) ←
      coreopsfunctionFnMutFTupleClause0_ItemOptionInst.call_mut self.f x
    ok (o1, { iter := t, f := t1 })
  | option.Option.None => ok (option.Option.None, { self with iter := t })

/-- Trait implementation: [core_models::iter::adapters::map_while::{impl core_models::iter::traits::iterator::Iterator<B> for core_models::iter::adapters::map_while::MapWhile<I, F>}]
    Source: 'core-models/src/core/iter.rs', lines 1009:8-1017:9 -/
@[reducible]
def
  iter.adapters.map_while.MapWhile.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {B : Type} {F : Type} {Clause0_Item : Type}
  (traitsiteratorIteratorInst : iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleClause0_ItemOptionInst : core.ops.function.FnMut F
  Clause0_Item (option.Option B)) : iter.traits.iterator.Iterator
  (iter.adapters.map_while.MapWhile I F) B := {
  next :=
    iter.adapters.map_while.MapWhile.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst coreopsfunctionFnMutFTupleClause0_ItemOptionInst
}

/-- [core_models::iter::adapters::inspect::{core_models::iter::adapters::inspect::Inspect<I, F>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 1028:12-1030:13
    Visibility: public -/
def iter.adapters.inspect.Inspect.new
  {I : Type} {F : Type} (iter1 : I) (f : F) :
  RustM (iter.adapters.inspect.Inspect I F)
  := do
  ok { iter := iter1, f }

/-- [core_models::iter::adapters::inspect::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::inspect::Inspect<I, F>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 1035:12-1043:13
    Visibility: public -/
def
  iter.adapters.inspect.Inspect.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {F : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleShared0Clause0_ItemTupleInst :
  core.ops.function.FnMut F Clause0_Item Unit)
  (self : iter.adapters.inspect.Inspect I F) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.inspect.Inspect I F))
  := do
  let (o, t) ← traitsiteratorIteratorInst.next self.iter
  match o with
  | option.Option.Some x =>
    let (_, t1) ←
      coreopsfunctionFnMutFTupleShared0Clause0_ItemTupleInst.call_mut self.f x
    ok (o, { iter := t, f := t1 })
  | option.Option.None => ok (option.Option.None, { self with iter := t })

/-- Trait implementation: [core_models::iter::adapters::inspect::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::inspect::Inspect<I, F>}]
    Source: 'core-models/src/core/iter.rs', lines 1033:8-1044:9 -/
@[reducible]
def iter.adapters.inspect.Inspect.Insts.CoreIterTraitsIteratorIterator
  {I : Type} {F : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (coreopsfunctionFnMutFTupleSharedClause0_ItemTupleInst :
  core.ops.function.FnMut F Clause0_Item Unit) : iter.traits.iterator.Iterator
  (iter.adapters.inspect.Inspect I F) Clause0_Item := {
  next :=
    iter.adapters.inspect.Inspect.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
    coreopsfunctionFnMutFTupleSharedClause0_ItemTupleInst
}

/-- [core_models::iter::adapters::fuse::{core_models::iter::adapters::fuse::Fuse<I>}::new]:
    Source: 'core-models/src/core/iter.rs', lines 1055:12-1057:13
    Visibility: public -/
def iter.adapters.fuse.Fuse.new
  {I : Type} (iter1 : I) : RustM (iter.adapters.fuse.Fuse I) := do
  ok { iter := iter1, done := false }

/-- [core_models::iter::adapters::fuse::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::fuse::Fuse<I>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 1062:12-1074:13
    Visibility: public -/
def iter.adapters.fuse.Fuse.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.fuse.Fuse I) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.fuse.Fuse I))
  := do
  if self.done
  then ok (option.Option.None, self)
  else
    let (o, t) ← traitsiteratorIteratorInst.next self.iter
    match o with
    | option.Option.Some _ => ok (o, { iter := t, done := false })
    | option.Option.None =>
      ok (option.Option.None, { iter := t, done := true })

/-- Trait implementation: [core_models::iter::adapters::fuse::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::fuse::Fuse<I>}]
    Source: 'core-models/src/core/iter.rs', lines 1060:8-1075:9 -/
@[reducible]
def iter.adapters.fuse.Fuse.Insts.CoreIterTraitsIteratorIterator {I :
  Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) : iter.traits.iterator.Iterator
  (iter.adapters.fuse.Fuse I) Clause0_Item := {
  next :=
    iter.adapters.fuse.Fuse.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
}

/-- [core_models::option::{core_models::option::Option<T>}::expect]:
    Source: 'core-models/src/core/option.rs', lines 65:4-70:5
    Visibility: public -/
def option.Option.expect
  {T : Type} (self : option.Option T) (_msg : Str) : RustM T := do
  match self with
  | option.Option.Some val => ok val
  | option.Option.None => panicking.internal.panic T

/-- [core_models::iter::range::Step::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1092:8-1094:9
    Visibility: public -/
@[trait_default]
def iter.range.Step.forward.default
  {Self : Type} (StepInst : iter.range.Step Self) (start : Self)
  (count : Std.Usize) :
  RustM Self
  := do
  let o ← StepInst.forward_checked start count
  option.Option.expect o (toStr "overflow in `Step::forward`")

/-- [core_models::iter::range::Step::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1096:8-1098:9
    Visibility: public -/
@[trait_default]
def iter.range.Step.forward_unchecked.default
  {Self : Type} (StepInst : iter.range.Step Self) (start : Self)
  (count : Std.Usize) :
  RustM Self
  := do
  StepInst.forward start count

/-- [core_models::iter::range::Step::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1100:8-1102:9
    Visibility: public -/
@[trait_default]
def iter.range.Step.backward.default
  {Self : Type} (StepInst : iter.range.Step Self) (start : Self)
  (count : Std.Usize) :
  RustM Self
  := do
  let o ← StepInst.backward_checked start count
  option.Option.expect o (toStr "overflow in `Step::backward`")

/-- [core_models::iter::range::Step::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1104:8-1106:9
    Visibility: public -/
@[trait_default]
def iter.range.Step.backward_unchecked.default
  {Self : Type} (StepInst : iter.range.Step Self) (start : Self)
  (count : Std.Usize) :
  RustM Self
  := do
  StepInst.backward start count

/-- [core_models::option::{core_models::option::Option<T>}::unwrap]:
    Source: 'core-models/src/core/option.rs', lines 74:4-79:5
    Visibility: public -/
def option.Option.unwrap {T : Type} (self : option.Option T) : RustM T := do
  match self with
  | option.Option.Some val => ok val
  | option.Option.None => panicking.internal.panic T

/-- [core_models::num::{core_models::num::i8}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 285:12-287:13
    Visibility: public -/
def num.I8.overflowing_add
  (x : Std.I8) (y : Std.I8) : RustM (Std.I8 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_i8 x y

/-- [core_models::num::{core_models::num::i8}::checked_add_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 329:12-338:13
    Visibility: public -/
def num.I8.checked_add_unsigned
  (x : Std.I8) (y : Std.U8) : RustM (option.Option Std.I8) := do
  let i ← lift (UScalar.hcast .I8 y)
  let (result1, overflowed) ← num.I8.overflowing_add x i
  let i1 ← lift (IScalar.hcast .U8 num.I8.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1111:12-1113:13
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.I8) (n : Std.Usize) : RustM Std.I8 := do
  let i ← lift (UScalar.cast .U8 n)
  let o ← num.I8.checked_add_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i16}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 285:12-287:13
    Visibility: public -/
def num.I16.overflowing_add
  (x : Std.I16) (y : Std.I16) : RustM (Std.I16 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_i16 x y

/-- [core_models::num::{core_models::num::i16}::checked_add_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 329:12-338:13
    Visibility: public -/
def num.I16.checked_add_unsigned
  (x : Std.I16) (y : Std.U16) : RustM (option.Option Std.I16) := do
  let i ← lift (UScalar.hcast .I16 y)
  let (result1, overflowed) ← num.I16.overflowing_add x i
  let i1 ← lift (IScalar.hcast .U16 num.I16.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1111:12-1113:13
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.I16) (n : Std.Usize) : RustM Std.I16 := do
  let i ← lift (UScalar.cast .U16 n)
  let o ← num.I16.checked_add_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i32}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 285:12-287:13
    Visibility: public -/
def num.I32.overflowing_add
  (x : Std.I32) (y : Std.I32) : RustM (Std.I32 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_i32 x y

/-- [core_models::num::{core_models::num::i32}::checked_add_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 329:12-338:13
    Visibility: public -/
def num.I32.checked_add_unsigned
  (x : Std.I32) (y : Std.U32) : RustM (option.Option Std.I32) := do
  let i ← lift (UScalar.hcast .I32 y)
  let (result1, overflowed) ← num.I32.overflowing_add x i
  let i1 ← lift (IScalar.hcast .U32 num.I32.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1111:12-1113:13
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.I32) (n : Std.Usize) : RustM Std.I32 := do
  let i ← lift (UScalar.cast .U32 n)
  let o ← num.I32.checked_add_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i64}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 285:12-287:13
    Visibility: public -/
def num.I64.overflowing_add
  (x : Std.I64) (y : Std.I64) : RustM (Std.I64 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_i64 x y

/-- [core_models::num::{core_models::num::i64}::checked_add_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 329:12-338:13
    Visibility: public -/
def num.I64.checked_add_unsigned
  (x : Std.I64) (y : Std.U64) : RustM (option.Option Std.I64) := do
  let i ← lift (UScalar.hcast .I64 y)
  let (result1, overflowed) ← num.I64.overflowing_add x i
  let i1 ← lift (IScalar.hcast .U64 num.I64.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1111:12-1113:13
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.I64) (n : Std.Usize) : RustM Std.I64 := do
  let i ← lift (UScalar.cast .U64 n)
  let o ← num.I64.checked_add_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::isize}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 285:12-287:13
    Visibility: public -/
def num.Isize.overflowing_add
  (x : Std.Isize) (y : Std.Isize) : RustM (Std.Isize × Bool) := do
  rust_primitives.arithmetic.overflowing_add_isize x y

/-- [core_models::num::{core_models::num::isize}::checked_add_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 329:12-338:13
    Visibility: public -/
def num.Isize.checked_add_unsigned
  (x : Std.Isize) (y : Std.Usize) : RustM (option.Option Std.Isize) := do
  let i ← lift (UScalar.hcast .Isize y)
  let (result1, overflowed) ← num.Isize.overflowing_add x i
  let i1 := num.Isize.MAX
  let i2 ← lift (IScalar.hcast .Usize i1)
  if overflowed = (y > i2)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1111:12-1113:13
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.Isize) (n : Std.Usize) : RustM Std.Isize := do
  let o ← num.Isize.checked_add_unsigned start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i128}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 285:12-287:13
    Visibility: public -/
def num.I128.overflowing_add
  (x : Std.I128) (y : Std.I128) : RustM (Std.I128 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_i128 x y

/-- [core_models::num::{core_models::num::i128}::checked_add_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 329:12-338:13
    Visibility: public -/
def num.I128.checked_add_unsigned
  (x : Std.I128) (y : Std.U128) : RustM (option.Option Std.I128) := do
  let i ← lift (UScalar.hcast .I128 y)
  let (result1, overflowed) ← num.I128.overflowing_add x i
  let i1 ← lift (IScalar.hcast .U128 num.I128.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1111:12-1113:13
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.I128) (n : Std.Usize) : RustM Std.I128 := do
  let i ← lift (UScalar.cast .U128 n)
  let o ← num.I128.checked_add_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i8}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 311:12-313:13
    Visibility: public -/
def num.I8.overflowing_sub
  (x : Std.I8) (y : Std.I8) : RustM (Std.I8 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_i8 x y

/-- [core_models::num::{core_models::num::i8}::checked_sub_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 340:12-347:13
    Visibility: public -/
def num.I8.checked_sub_unsigned
  (x : Std.I8) (y : Std.U8) : RustM (option.Option Std.I8) := do
  let i ← lift (UScalar.hcast .I8 y)
  let (result1, overflowed) ← num.I8.overflowing_sub x i
  let i1 ← lift (IScalar.hcast .U8 num.I8.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1115:12-1117:13
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.I8) (n : Std.Usize) : RustM Std.I8 := do
  let i ← lift (UScalar.cast .U8 n)
  let o ← num.I8.checked_sub_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i16}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 311:12-313:13
    Visibility: public -/
def num.I16.overflowing_sub
  (x : Std.I16) (y : Std.I16) : RustM (Std.I16 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_i16 x y

/-- [core_models::num::{core_models::num::i16}::checked_sub_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 340:12-347:13
    Visibility: public -/
def num.I16.checked_sub_unsigned
  (x : Std.I16) (y : Std.U16) : RustM (option.Option Std.I16) := do
  let i ← lift (UScalar.hcast .I16 y)
  let (result1, overflowed) ← num.I16.overflowing_sub x i
  let i1 ← lift (IScalar.hcast .U16 num.I16.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1115:12-1117:13
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.I16) (n : Std.Usize) : RustM Std.I16 := do
  let i ← lift (UScalar.cast .U16 n)
  let o ← num.I16.checked_sub_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i32}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 311:12-313:13
    Visibility: public -/
def num.I32.overflowing_sub
  (x : Std.I32) (y : Std.I32) : RustM (Std.I32 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_i32 x y

/-- [core_models::num::{core_models::num::i32}::checked_sub_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 340:12-347:13
    Visibility: public -/
def num.I32.checked_sub_unsigned
  (x : Std.I32) (y : Std.U32) : RustM (option.Option Std.I32) := do
  let i ← lift (UScalar.hcast .I32 y)
  let (result1, overflowed) ← num.I32.overflowing_sub x i
  let i1 ← lift (IScalar.hcast .U32 num.I32.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1115:12-1117:13
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.I32) (n : Std.Usize) : RustM Std.I32 := do
  let i ← lift (UScalar.cast .U32 n)
  let o ← num.I32.checked_sub_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i64}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 311:12-313:13
    Visibility: public -/
def num.I64.overflowing_sub
  (x : Std.I64) (y : Std.I64) : RustM (Std.I64 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_i64 x y

/-- [core_models::num::{core_models::num::i64}::checked_sub_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 340:12-347:13
    Visibility: public -/
def num.I64.checked_sub_unsigned
  (x : Std.I64) (y : Std.U64) : RustM (option.Option Std.I64) := do
  let i ← lift (UScalar.hcast .I64 y)
  let (result1, overflowed) ← num.I64.overflowing_sub x i
  let i1 ← lift (IScalar.hcast .U64 num.I64.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1115:12-1117:13
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.I64) (n : Std.Usize) : RustM Std.I64 := do
  let i ← lift (UScalar.cast .U64 n)
  let o ← num.I64.checked_sub_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::isize}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 311:12-313:13
    Visibility: public -/
def num.Isize.overflowing_sub
  (x : Std.Isize) (y : Std.Isize) : RustM (Std.Isize × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_isize x y

/-- [core_models::num::{core_models::num::isize}::checked_sub_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 340:12-347:13
    Visibility: public -/
def num.Isize.checked_sub_unsigned
  (x : Std.Isize) (y : Std.Usize) : RustM (option.Option Std.Isize) := do
  let i ← lift (UScalar.hcast .Isize y)
  let (result1, overflowed) ← num.Isize.overflowing_sub x i
  let i1 := num.Isize.MAX
  let i2 ← lift (IScalar.hcast .Usize i1)
  if overflowed = (y > i2)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1115:12-1117:13
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.Isize) (n : Std.Usize) : RustM Std.Isize := do
  let o ← num.Isize.checked_sub_unsigned start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i128}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 311:12-313:13
    Visibility: public -/
def num.I128.overflowing_sub
  (x : Std.I128) (y : Std.I128) : RustM (Std.I128 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_i128 x y

/-- [core_models::num::{core_models::num::i128}::checked_sub_unsigned]:
    Source: 'core-models/src/core/num/mod.rs', lines 340:12-347:13
    Visibility: public -/
def num.I128.checked_sub_unsigned
  (x : Std.I128) (y : Std.U128) : RustM (option.Option Std.I128) := do
  let i ← lift (UScalar.hcast .I128 y)
  let (result1, overflowed) ← num.I128.overflowing_sub x i
  let i1 ← lift (IScalar.hcast .U128 num.I128.MAX)
  if overflowed = (y > i1)
  then ok (option.Option.Some result1)
  else ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1115:12-1117:13
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.I128) (n : Std.Usize) : RustM Std.I128 := do
  let i ← lift (UScalar.cast .U128 n)
  let o ← num.I128.checked_sub_unsigned start i
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u8}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 53:12-55:13
    Visibility: public -/
def num.U8.unchecked_add (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  x + y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1123:12-1125:13
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.U8) (n : Std.Usize) : RustM Std.U8 := do
  let i ← lift (UScalar.cast .U8 n)
  num.U8.unchecked_add start i

/-- [core_models::num::{core_models::num::u16}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 53:12-55:13
    Visibility: public -/
def num.U16.unchecked_add (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  x + y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1123:12-1125:13
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.U16) (n : Std.Usize) : RustM Std.U16 := do
  let i ← lift (UScalar.cast .U16 n)
  num.U16.unchecked_add start i

/-- [core_models::num::{core_models::num::u32}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 53:12-55:13
    Visibility: public -/
def num.U32.unchecked_add (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  x + y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1123:12-1125:13
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.U32) (n : Std.Usize) : RustM Std.U32 := do
  let i ← lift (UScalar.cast .U32 n)
  num.U32.unchecked_add start i

/-- [core_models::num::{core_models::num::u64}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 53:12-55:13
    Visibility: public -/
def num.U64.unchecked_add (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  x + y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1123:12-1125:13
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.U64) (n : Std.Usize) : RustM Std.U64 := do
  let i ← lift (UScalar.cast .U64 n)
  num.U64.unchecked_add start i

/-- [core_models::num::{core_models::num::usize}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 53:12-55:13
    Visibility: public -/
def num.Usize.unchecked_add
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  x + y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1123:12-1125:13
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.Usize) (n : Std.Usize) : RustM Std.Usize := do
  num.Usize.unchecked_add start n

/-- [core_models::num::{core_models::num::u128}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 53:12-55:13
    Visibility: public -/
def num.U128.unchecked_add (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  x + y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::forward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1123:12-1125:13
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.forward_unchecked
  (start : Std.U128) (n : Std.Usize) : RustM Std.U128 := do
  let i ← lift (UScalar.cast .U128 n)
  num.U128.unchecked_add start i

/-- [core_models::num::{core_models::num::u8}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 79:12-81:13
    Visibility: public -/
def num.U8.unchecked_sub (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  x - y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1127:12-1129:13
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.U8) (n : Std.Usize) : RustM Std.U8 := do
  let i ← lift (UScalar.cast .U8 n)
  num.U8.unchecked_sub start i

/-- [core_models::num::{core_models::num::u16}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 79:12-81:13
    Visibility: public -/
def num.U16.unchecked_sub (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  x - y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1127:12-1129:13
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.U16) (n : Std.Usize) : RustM Std.U16 := do
  let i ← lift (UScalar.cast .U16 n)
  num.U16.unchecked_sub start i

/-- [core_models::num::{core_models::num::u32}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 79:12-81:13
    Visibility: public -/
def num.U32.unchecked_sub (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  x - y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1127:12-1129:13
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.U32) (n : Std.Usize) : RustM Std.U32 := do
  let i ← lift (UScalar.cast .U32 n)
  num.U32.unchecked_sub start i

/-- [core_models::num::{core_models::num::u64}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 79:12-81:13
    Visibility: public -/
def num.U64.unchecked_sub (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  x - y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1127:12-1129:13
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.U64) (n : Std.Usize) : RustM Std.U64 := do
  let i ← lift (UScalar.cast .U64 n)
  num.U64.unchecked_sub start i

/-- [core_models::num::{core_models::num::usize}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 79:12-81:13
    Visibility: public -/
def num.Usize.unchecked_sub
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  x - y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1127:12-1129:13
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.Usize) (n : Std.Usize) : RustM Std.Usize := do
  num.Usize.unchecked_sub start n

/-- [core_models::num::{core_models::num::u128}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 79:12-81:13
    Visibility: public -/
def num.U128.unchecked_sub (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  x - y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::backward_unchecked]:
    Source: 'core-models/src/core/iter.rs', lines 1127:12-1129:13
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.backward_unchecked
  (start : Std.U128) (n : Std.Usize) : RustM Std.U128 := do
  let i ← lift (UScalar.cast .U128 n)
  num.U128.unchecked_sub start i

/-- [core_models::num::{core_models::num::u8}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 39:12-41:13
    Visibility: public -/
def num.U8.overflowing_add
  (x : Std.U8) (y : Std.U8) : RustM (Std.U8 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_u8 x y

/-- [core_models::num::{core_models::num::u8}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 43:12-50:13
    Visibility: public -/
def num.U8.checked_add
  (x : Std.U8) (y : Std.U8) : RustM (option.Option Std.U8) := do
  let (result1, overflowed) ← num.U8.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1168:20-1173:21
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.forward_checked
  (start : Std.U8) (n : Std.Usize) : RustM (option.Option Std.U8) := do
  let r ← U8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U8.checked_add start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.forward
  (start : Std.U8) (n : Std.Usize) : RustM Std.U8 := do
  let o ← U8.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i8}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 277:12-279:13
    Visibility: public -/
def num.I8.wrapping_add (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.wrapping_add_i8 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1201:20-1219:21
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.forward_checked
  (start : Std.I8) (n : Std.Usize) : RustM (option.Option Std.I8) := do
  let r ← U8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I8 n1)
    let wrapped ← num.I8.wrapping_add start i
    if wrapped >= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.forward
  (start : Std.I8) (n : Std.Usize) : RustM Std.I8 := do
  let o ← I8.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u16}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 39:12-41:13
    Visibility: public -/
def num.U16.overflowing_add
  (x : Std.U16) (y : Std.U16) : RustM (Std.U16 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_u16 x y

/-- [core_models::num::{core_models::num::u16}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 43:12-50:13
    Visibility: public -/
def num.U16.checked_add
  (x : Std.U16) (y : Std.U16) : RustM (option.Option Std.U16) := do
  let (result1, overflowed) ← num.U16.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1168:20-1173:21
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.forward_checked
  (start : Std.U16) (n : Std.Usize) : RustM (option.Option Std.U16) := do
  let r ← U16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U16.checked_add start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.forward
  (start : Std.U16) (n : Std.Usize) : RustM Std.U16 := do
  let o ← U16.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i16}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 277:12-279:13
    Visibility: public -/
def num.I16.wrapping_add (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.wrapping_add_i16 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1201:20-1219:21
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.forward_checked
  (start : Std.I16) (n : Std.Usize) : RustM (option.Option Std.I16) := do
  let r ← U16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I16 n1)
    let wrapped ← num.I16.wrapping_add start i
    if wrapped >= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.forward
  (start : Std.I16) (n : Std.Usize) : RustM Std.I16 := do
  let o ← I16.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u32}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 39:12-41:13
    Visibility: public -/
def num.U32.overflowing_add
  (x : Std.U32) (y : Std.U32) : RustM (Std.U32 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_u32 x y

/-- [core_models::num::{core_models::num::u32}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 43:12-50:13
    Visibility: public -/
def num.U32.checked_add
  (x : Std.U32) (y : Std.U32) : RustM (option.Option Std.U32) := do
  let (result1, overflowed) ← num.U32.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1168:20-1173:21
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.forward_checked
  (start : Std.U32) (n : Std.Usize) : RustM (option.Option Std.U32) := do
  let r ← U32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U32.checked_add start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.forward
  (start : Std.U32) (n : Std.Usize) : RustM Std.U32 := do
  let o ← U32.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i32}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 277:12-279:13
    Visibility: public -/
def num.I32.wrapping_add (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.wrapping_add_i32 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1201:20-1219:21
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.forward_checked
  (start : Std.I32) (n : Std.Usize) : RustM (option.Option Std.I32) := do
  let r ← U32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I32 n1)
    let wrapped ← num.I32.wrapping_add start i
    if wrapped >= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.forward
  (start : Std.I32) (n : Std.Usize) : RustM Std.I32 := do
  let o ← I32.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u64}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 39:12-41:13
    Visibility: public -/
def num.U64.overflowing_add
  (x : Std.U64) (y : Std.U64) : RustM (Std.U64 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_u64 x y

/-- [core_models::num::{core_models::num::u64}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 43:12-50:13
    Visibility: public -/
def num.U64.checked_add
  (x : Std.U64) (y : Std.U64) : RustM (option.Option Std.U64) := do
  let (result1, overflowed) ← num.U64.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1168:20-1173:21
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.forward_checked
  (start : Std.U64) (n : Std.Usize) : RustM (option.Option Std.U64) := do
  let r ← U64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U64.checked_add start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.forward
  (start : Std.U64) (n : Std.Usize) : RustM Std.U64 := do
  let o ← U64.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i64}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 277:12-279:13
    Visibility: public -/
def num.I64.wrapping_add (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.wrapping_add_i64 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1201:20-1219:21
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.forward_checked
  (start : Std.I64) (n : Std.Usize) : RustM (option.Option Std.I64) := do
  let r ← U64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I64 n1)
    let wrapped ← num.I64.wrapping_add start i
    if wrapped >= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.forward
  (start : Std.I64) (n : Std.Usize) : RustM Std.I64 := do
  let o ← I64.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::usize}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 39:12-41:13
    Visibility: public -/
def num.Usize.overflowing_add
  (x : Std.Usize) (y : Std.Usize) : RustM (Std.Usize × Bool) := do
  rust_primitives.arithmetic.overflowing_add_usize x y

/-- [core_models::num::{core_models::num::usize}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 43:12-50:13
    Visibility: public -/
def num.Usize.checked_add
  (x : Std.Usize) (y : Std.Usize) : RustM (option.Option Std.Usize) := do
  let (result1, overflowed) ← num.Usize.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1168:20-1173:21
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.forward_checked
  (start : Std.Usize) (n : Std.Usize) : RustM (option.Option Std.Usize) := do
  let r ←
    convert.TryFromUTInfallible.Blanket.try_from (convert.From.Blanket
      Std.Usize) n
  match r with
  | core.result.Result.Ok n1 => num.Usize.checked_add start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.forward
  (start : Std.Usize) (n : Std.Usize) : RustM Std.Usize := do
  let o ← Usize.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::isize}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 277:12-279:13
    Visibility: public -/
def num.Isize.wrapping_add
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.wrapping_add_isize x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1201:20-1219:21
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.forward_checked
  (start : Std.Isize) (n : Std.Usize) : RustM (option.Option Std.Isize) := do
  let r ←
    convert.TryFromUTInfallible.Blanket.try_from (convert.From.Blanket
      Std.Usize) n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .Isize n1)
    let wrapped ← num.Isize.wrapping_add start i
    if wrapped >= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.forward
  (start : Std.Isize) (n : Std.Usize) : RustM Std.Isize := do
  let o ← Isize.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u128}::overflowing_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 39:12-41:13
    Visibility: public -/
def num.U128.overflowing_add
  (x : Std.U128) (y : Std.U128) : RustM (Std.U128 × Bool) := do
  rust_primitives.arithmetic.overflowing_add_u128 x y

/-- [core_models::num::{core_models::num::u128}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 43:12-50:13
    Visibility: public -/
def num.U128.checked_add
  (x : Std.U128) (y : Std.U128) : RustM (option.Option Std.U128) := do
  let (result1, overflowed) ← num.U128.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1260:20-1262:21
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.forward_checked
  (start : Std.U128) (n : Std.Usize) : RustM (option.Option Std.U128) := do
  let i ← lift (UScalar.cast .U128 n)
  num.U128.checked_add start i

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.forward
  (start : Std.U128) (n : Std.Usize) : RustM Std.U128 := do
  let o ← U128.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i128}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 289:12-296:13
    Visibility: public -/
def num.I128.checked_add
  (x : Std.I128) (y : Std.I128) : RustM (option.Option Std.I128) := do
  let (result1, overflowed) ← num.I128.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::forward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1292:20-1294:21
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.forward_checked
  (start : Std.I128) (n : Std.Usize) : RustM (option.Option Std.I128) := do
  let i ← lift (UScalar.hcast .I128 n)
  num.I128.checked_add start i

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::forward]:
    Source: 'core-models/src/core/iter.rs', lines 1135:12-1137:13
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.forward
  (start : Std.I128) (n : Std.Usize) : RustM Std.I128 := do
  let o ← I128.Insts.CoreIterRangeStep.forward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u8}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 65:12-67:13
    Visibility: public -/
def num.U8.overflowing_sub
  (x : Std.U8) (y : Std.U8) : RustM (Std.U8 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_u8 x y

/-- [core_models::num::{core_models::num::u8}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 69:12-76:13
    Visibility: public -/
def num.U8.checked_sub
  (x : Std.U8) (y : Std.U8) : RustM (option.Option Std.U8) := do
  let (result1, overflowed) ← num.U8.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1175:20-1180:21
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.backward_checked
  (start : Std.U8) (n : Std.Usize) : RustM (option.Option Std.U8) := do
  let r ← U8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U8.checked_sub start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.backward
  (start : Std.U8) (n : Std.Usize) : RustM Std.U8 := do
  let o ← U8.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i8}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 303:12-305:13
    Visibility: public -/
def num.I8.wrapping_sub (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.wrapping_sub_i8 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1221:20-1239:21
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.backward_checked
  (start : Std.I8) (n : Std.Usize) : RustM (option.Option Std.I8) := do
  let r ← U8.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I8 n1)
    let wrapped ← num.I8.wrapping_sub start i
    if wrapped <= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.backward
  (start : Std.I8) (n : Std.Usize) : RustM Std.I8 := do
  let o ← I8.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u16}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 65:12-67:13
    Visibility: public -/
def num.U16.overflowing_sub
  (x : Std.U16) (y : Std.U16) : RustM (Std.U16 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_u16 x y

/-- [core_models::num::{core_models::num::u16}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 69:12-76:13
    Visibility: public -/
def num.U16.checked_sub
  (x : Std.U16) (y : Std.U16) : RustM (option.Option Std.U16) := do
  let (result1, overflowed) ← num.U16.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1175:20-1180:21
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.backward_checked
  (start : Std.U16) (n : Std.Usize) : RustM (option.Option Std.U16) := do
  let r ← U16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U16.checked_sub start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.backward
  (start : Std.U16) (n : Std.Usize) : RustM Std.U16 := do
  let o ← U16.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i16}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 303:12-305:13
    Visibility: public -/
def num.I16.wrapping_sub (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.wrapping_sub_i16 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1221:20-1239:21
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.backward_checked
  (start : Std.I16) (n : Std.Usize) : RustM (option.Option Std.I16) := do
  let r ← U16.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I16 n1)
    let wrapped ← num.I16.wrapping_sub start i
    if wrapped <= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.backward
  (start : Std.I16) (n : Std.Usize) : RustM Std.I16 := do
  let o ← I16.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u32}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 65:12-67:13
    Visibility: public -/
def num.U32.overflowing_sub
  (x : Std.U32) (y : Std.U32) : RustM (Std.U32 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_u32 x y

/-- [core_models::num::{core_models::num::u32}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 69:12-76:13
    Visibility: public -/
def num.U32.checked_sub
  (x : Std.U32) (y : Std.U32) : RustM (option.Option Std.U32) := do
  let (result1, overflowed) ← num.U32.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1175:20-1180:21
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.backward_checked
  (start : Std.U32) (n : Std.Usize) : RustM (option.Option Std.U32) := do
  let r ← U32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U32.checked_sub start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.backward
  (start : Std.U32) (n : Std.Usize) : RustM Std.U32 := do
  let o ← U32.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i32}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 303:12-305:13
    Visibility: public -/
def num.I32.wrapping_sub (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.wrapping_sub_i32 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1221:20-1239:21
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.backward_checked
  (start : Std.I32) (n : Std.Usize) : RustM (option.Option Std.I32) := do
  let r ← U32.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I32 n1)
    let wrapped ← num.I32.wrapping_sub start i
    if wrapped <= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.backward
  (start : Std.I32) (n : Std.Usize) : RustM Std.I32 := do
  let o ← I32.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u64}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 65:12-67:13
    Visibility: public -/
def num.U64.overflowing_sub
  (x : Std.U64) (y : Std.U64) : RustM (Std.U64 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_u64 x y

/-- [core_models::num::{core_models::num::u64}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 69:12-76:13
    Visibility: public -/
def num.U64.checked_sub
  (x : Std.U64) (y : Std.U64) : RustM (option.Option Std.U64) := do
  let (result1, overflowed) ← num.U64.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1175:20-1180:21
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.backward_checked
  (start : Std.U64) (n : Std.Usize) : RustM (option.Option Std.U64) := do
  let r ← U64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 => num.U64.checked_sub start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.backward
  (start : Std.U64) (n : Std.Usize) : RustM Std.U64 := do
  let o ← U64.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i64}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 303:12-305:13
    Visibility: public -/
def num.I64.wrapping_sub (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.wrapping_sub_i64 x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1221:20-1239:21
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.backward_checked
  (start : Std.I64) (n : Std.Usize) : RustM (option.Option Std.I64) := do
  let r ← U64.Insts.CoreConvertTryFromUsizeTryFromIntError.try_from n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .I64 n1)
    let wrapped ← num.I64.wrapping_sub start i
    if wrapped <= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.backward
  (start : Std.I64) (n : Std.Usize) : RustM Std.I64 := do
  let o ← I64.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::usize}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 65:12-67:13
    Visibility: public -/
def num.Usize.overflowing_sub
  (x : Std.Usize) (y : Std.Usize) : RustM (Std.Usize × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_usize x y

/-- [core_models::num::{core_models::num::usize}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 69:12-76:13
    Visibility: public -/
def num.Usize.checked_sub
  (x : Std.Usize) (y : Std.Usize) : RustM (option.Option Std.Usize) := do
  let (result1, overflowed) ← num.Usize.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1175:20-1180:21
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.backward_checked
  (start : Std.Usize) (n : Std.Usize) : RustM (option.Option Std.Usize) := do
  let r ←
    convert.TryFromUTInfallible.Blanket.try_from (convert.From.Blanket
      Std.Usize) n
  match r with
  | core.result.Result.Ok n1 => num.Usize.checked_sub start n1
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.backward
  (start : Std.Usize) (n : Std.Usize) : RustM Std.Usize := do
  let o ← Usize.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::isize}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 303:12-305:13
    Visibility: public -/
def num.Isize.wrapping_sub
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.wrapping_sub_isize x y

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1221:20-1239:21
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.backward_checked
  (start : Std.Isize) (n : Std.Usize) : RustM (option.Option Std.Isize) := do
  let r ←
    convert.TryFromUTInfallible.Blanket.try_from (convert.From.Blanket
      Std.Usize) n
  match r with
  | core.result.Result.Ok n1 =>
    let i ← lift (UScalar.hcast .Isize n1)
    let wrapped ← num.Isize.wrapping_sub start i
    if wrapped <= start
    then ok (option.Option.Some wrapped)
    else ok option.Option.None
  | core.result.Result.Err _ => ok option.Option.None

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.backward
  (start : Std.Isize) (n : Std.Usize) : RustM Std.Isize := do
  let o ← Isize.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::u128}::overflowing_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 65:12-67:13
    Visibility: public -/
def num.U128.overflowing_sub
  (x : Std.U128) (y : Std.U128) : RustM (Std.U128 × Bool) := do
  rust_primitives.arithmetic.overflowing_sub_u128 x y

/-- [core_models::num::{core_models::num::u128}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 69:12-76:13
    Visibility: public -/
def num.U128.checked_sub
  (x : Std.U128) (y : Std.U128) : RustM (option.Option Std.U128) := do
  let (result1, overflowed) ← num.U128.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1264:20-1266:21
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.backward_checked
  (start : Std.U128) (n : Std.Usize) : RustM (option.Option Std.U128) := do
  let i ← lift (UScalar.cast .U128 n)
  num.U128.checked_sub start i

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.backward
  (start : Std.U128) (n : Std.Usize) : RustM Std.U128 := do
  let o ← U128.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::num::{core_models::num::i128}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 315:12-322:13
    Visibility: public -/
def num.I128.checked_sub
  (x : Std.I128) (y : Std.I128) : RustM (option.Option Std.I128) := do
  let (result1, overflowed) ← num.I128.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::backward_checked]:
    Source: 'core-models/src/core/iter.rs', lines 1296:20-1298:21
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.backward_checked
  (start : Std.I128) (n : Std.Usize) : RustM (option.Option Std.I128) := do
  let i ← lift (UScalar.hcast .I128 n)
  num.I128.checked_sub start i

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::backward]:
    Source: 'core-models/src/core/iter.rs', lines 1139:12-1141:13
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.backward
  (start : Std.I128) (n : Std.Usize) : RustM Std.I128 := do
  let o ← I128.Insts.CoreIterRangeStep.backward_checked start n
  option.Option.unwrap o

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u8}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1158:20-1166:21
    Visibility: public -/
def U8.Insts.CoreIterRangeStep.steps_between
  (start : Std.U8) («end» : Std.U8) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← «end» - start
    let steps ← lift (UScalar.cast .Usize i)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for u8}]
    Source: 'core-models/src/core/iter.rs', lines 1154:16-1181:17 -/
@[reducible]
def U8.Insts.CoreIterRangeStep : iter.range.Step Std.U8 := {
  cloneCloneInst := U8.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.U8.Insts.CoreCmpPartialOrdU8
  steps_between := U8.Insts.CoreIterRangeStep.steps_between
  forward_checked := U8.Insts.CoreIterRangeStep.forward_checked
  backward_checked := U8.Insts.CoreIterRangeStep.backward_checked
  forward := U8.Insts.CoreIterRangeStep.forward
  forward_unchecked := U8.Insts.CoreIterRangeStep.forward_unchecked
  backward := U8.Insts.CoreIterRangeStep.backward
  backward_unchecked := U8.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u16}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1158:20-1166:21
    Visibility: public -/
def U16.Insts.CoreIterRangeStep.steps_between
  (start : Std.U16) («end» : Std.U16) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← «end» - start
    let steps ← lift (UScalar.cast .Usize i)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for u16}]
    Source: 'core-models/src/core/iter.rs', lines 1154:16-1181:17 -/
@[reducible]
def U16.Insts.CoreIterRangeStep : iter.range.Step Std.U16 := {
  cloneCloneInst := U16.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.U16.Insts.CoreCmpPartialOrdU16
  steps_between := U16.Insts.CoreIterRangeStep.steps_between
  forward_checked := U16.Insts.CoreIterRangeStep.forward_checked
  backward_checked := U16.Insts.CoreIterRangeStep.backward_checked
  forward := U16.Insts.CoreIterRangeStep.forward
  forward_unchecked := U16.Insts.CoreIterRangeStep.forward_unchecked
  backward := U16.Insts.CoreIterRangeStep.backward
  backward_unchecked := U16.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u32}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1158:20-1166:21
    Visibility: public -/
def U32.Insts.CoreIterRangeStep.steps_between
  (start : Std.U32) («end» : Std.U32) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← «end» - start
    let steps ← lift (UScalar.cast .Usize i)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for u32}]
    Source: 'core-models/src/core/iter.rs', lines 1154:16-1181:17 -/
@[reducible]
def U32.Insts.CoreIterRangeStep : iter.range.Step Std.U32 := {
  cloneCloneInst := U32.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.U32.Insts.CoreCmpPartialOrdU32
  steps_between := U32.Insts.CoreIterRangeStep.steps_between
  forward_checked := U32.Insts.CoreIterRangeStep.forward_checked
  backward_checked := U32.Insts.CoreIterRangeStep.backward_checked
  forward := U32.Insts.CoreIterRangeStep.forward
  forward_unchecked := U32.Insts.CoreIterRangeStep.forward_unchecked
  backward := U32.Insts.CoreIterRangeStep.backward
  backward_unchecked := U32.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u64}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1158:20-1166:21
    Visibility: public -/
def U64.Insts.CoreIterRangeStep.steps_between
  (start : Std.U64) («end» : Std.U64) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← «end» - start
    let steps ← lift (UScalar.cast .Usize i)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for u64}]
    Source: 'core-models/src/core/iter.rs', lines 1154:16-1181:17 -/
@[reducible]
def U64.Insts.CoreIterRangeStep : iter.range.Step Std.U64 := {
  cloneCloneInst := U64.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.U64.Insts.CoreCmpPartialOrdU64
  steps_between := U64.Insts.CoreIterRangeStep.steps_between
  forward_checked := U64.Insts.CoreIterRangeStep.forward_checked
  backward_checked := U64.Insts.CoreIterRangeStep.backward_checked
  forward := U64.Insts.CoreIterRangeStep.forward
  forward_unchecked := U64.Insts.CoreIterRangeStep.forward_unchecked
  backward := U64.Insts.CoreIterRangeStep.backward
  backward_unchecked := U64.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for usize}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1158:20-1166:21
    Visibility: public -/
def Usize.Insts.CoreIterRangeStep.steps_between
  (start : Std.Usize) («end» : Std.Usize) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then let steps ← «end» - start
       ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for usize}]
    Source: 'core-models/src/core/iter.rs', lines 1154:16-1181:17 -/
@[reducible]
def Usize.Insts.CoreIterRangeStep : iter.range.Step Std.Usize := {
  cloneCloneInst := Usize.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.Usize.Insts.CoreCmpPartialOrdUsize
  steps_between := Usize.Insts.CoreIterRangeStep.steps_between
  forward_checked := Usize.Insts.CoreIterRangeStep.forward_checked
  backward_checked := Usize.Insts.CoreIterRangeStep.backward_checked
  forward := Usize.Insts.CoreIterRangeStep.forward
  forward_unchecked := Usize.Insts.CoreIterRangeStep.forward_unchecked
  backward := Usize.Insts.CoreIterRangeStep.backward
  backward_unchecked := Usize.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i8}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1188:20-1199:21
    Visibility: public -/
def I8.Insts.CoreIterRangeStep.steps_between
  (start : Std.I8) («end» : Std.I8) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← lift (IScalar.cast .Isize «end»)
    let i1 ← lift (IScalar.cast .Isize start)
    let i2 ← num.Isize.wrapping_sub i i1
    let steps ← lift (IScalar.hcast .Usize i2)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for i8}]
    Source: 'core-models/src/core/iter.rs', lines 1184:16-1240:17 -/
@[reducible]
def I8.Insts.CoreIterRangeStep : iter.range.Step Std.I8 := {
  cloneCloneInst := I8.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.I8.Insts.CoreCmpPartialOrdI8
  steps_between := I8.Insts.CoreIterRangeStep.steps_between
  forward_checked := I8.Insts.CoreIterRangeStep.forward_checked
  backward_checked := I8.Insts.CoreIterRangeStep.backward_checked
  forward := I8.Insts.CoreIterRangeStep.forward
  forward_unchecked := I8.Insts.CoreIterRangeStep.forward_unchecked
  backward := I8.Insts.CoreIterRangeStep.backward
  backward_unchecked := I8.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i16}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1188:20-1199:21
    Visibility: public -/
def I16.Insts.CoreIterRangeStep.steps_between
  (start : Std.I16) («end» : Std.I16) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← lift (IScalar.cast .Isize «end»)
    let i1 ← lift (IScalar.cast .Isize start)
    let i2 ← num.Isize.wrapping_sub i i1
    let steps ← lift (IScalar.hcast .Usize i2)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for i16}]
    Source: 'core-models/src/core/iter.rs', lines 1184:16-1240:17 -/
@[reducible]
def I16.Insts.CoreIterRangeStep : iter.range.Step Std.I16 := {
  cloneCloneInst := I16.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.I16.Insts.CoreCmpPartialOrdI16
  steps_between := I16.Insts.CoreIterRangeStep.steps_between
  forward_checked := I16.Insts.CoreIterRangeStep.forward_checked
  backward_checked := I16.Insts.CoreIterRangeStep.backward_checked
  forward := I16.Insts.CoreIterRangeStep.forward
  forward_unchecked := I16.Insts.CoreIterRangeStep.forward_unchecked
  backward := I16.Insts.CoreIterRangeStep.backward
  backward_unchecked := I16.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i32}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1188:20-1199:21
    Visibility: public -/
def I32.Insts.CoreIterRangeStep.steps_between
  (start : Std.I32) («end» : Std.I32) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← lift (IScalar.cast .Isize «end»)
    let i1 ← lift (IScalar.cast .Isize start)
    let i2 ← num.Isize.wrapping_sub i i1
    let steps ← lift (IScalar.hcast .Usize i2)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for i32}]
    Source: 'core-models/src/core/iter.rs', lines 1184:16-1240:17 -/
@[reducible]
def I32.Insts.CoreIterRangeStep : iter.range.Step Std.I32 := {
  cloneCloneInst := I32.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.I32.Insts.CoreCmpPartialOrdI32
  steps_between := I32.Insts.CoreIterRangeStep.steps_between
  forward_checked := I32.Insts.CoreIterRangeStep.forward_checked
  backward_checked := I32.Insts.CoreIterRangeStep.backward_checked
  forward := I32.Insts.CoreIterRangeStep.forward
  forward_unchecked := I32.Insts.CoreIterRangeStep.forward_unchecked
  backward := I32.Insts.CoreIterRangeStep.backward
  backward_unchecked := I32.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i64}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1188:20-1199:21
    Visibility: public -/
def I64.Insts.CoreIterRangeStep.steps_between
  (start : Std.I64) («end» : Std.I64) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← lift (IScalar.cast .Isize «end»)
    let i1 ← lift (IScalar.cast .Isize start)
    let i2 ← num.Isize.wrapping_sub i i1
    let steps ← lift (IScalar.hcast .Usize i2)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for i64}]
    Source: 'core-models/src/core/iter.rs', lines 1184:16-1240:17 -/
@[reducible]
def I64.Insts.CoreIterRangeStep : iter.range.Step Std.I64 := {
  cloneCloneInst := I64.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.I64.Insts.CoreCmpPartialOrdI64
  steps_between := I64.Insts.CoreIterRangeStep.steps_between
  forward_checked := I64.Insts.CoreIterRangeStep.forward_checked
  backward_checked := I64.Insts.CoreIterRangeStep.backward_checked
  forward := I64.Insts.CoreIterRangeStep.forward
  forward_unchecked := I64.Insts.CoreIterRangeStep.forward_unchecked
  backward := I64.Insts.CoreIterRangeStep.backward
  backward_unchecked := I64.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for isize}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1188:20-1199:21
    Visibility: public -/
def Isize.Insts.CoreIterRangeStep.steps_between
  (start : Std.Isize) («end» : Std.Isize) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← num.Isize.wrapping_sub «end» start
    let steps ← lift (IScalar.hcast .Usize i)
    ok (steps, option.Option.Some steps)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for isize}]
    Source: 'core-models/src/core/iter.rs', lines 1184:16-1240:17 -/
@[reducible]
def Isize.Insts.CoreIterRangeStep : iter.range.Step Std.Isize := {
  cloneCloneInst := Isize.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.Isize.Insts.CoreCmpPartialOrdIsize
  steps_between := Isize.Insts.CoreIterRangeStep.steps_between
  forward_checked := Isize.Insts.CoreIterRangeStep.forward_checked
  backward_checked := Isize.Insts.CoreIterRangeStep.backward_checked
  forward := Isize.Insts.CoreIterRangeStep.forward
  forward_unchecked := Isize.Insts.CoreIterRangeStep.forward_unchecked
  backward := Isize.Insts.CoreIterRangeStep.backward
  backward_unchecked := Isize.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for u128}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1249:20-1258:21
    Visibility: public -/
def U128.Insts.CoreIterRangeStep.steps_between
  (start : Std.U128) («end» : Std.U128) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let i ← «end» - start
    let r ←
      Usize.Insts.CoreConvertTryFromU128TryFromIntError.try_from i
    match r with
    | core.result.Result.Ok steps => ok (steps, option.Option.Some steps)
    | core.result.Result.Err _ => ok (core.num.Usize.MAX, option.Option.None)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for u128}]
    Source: 'core-models/src/core/iter.rs', lines 1245:16-1267:17 -/
@[reducible]
def U128.Insts.CoreIterRangeStep : iter.range.Step Std.U128 := {
  cloneCloneInst := U128.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.U128.Insts.CoreCmpPartialOrdU128
  steps_between := U128.Insts.CoreIterRangeStep.steps_between
  forward_checked := U128.Insts.CoreIterRangeStep.forward_checked
  backward_checked := U128.Insts.CoreIterRangeStep.backward_checked
  forward := U128.Insts.CoreIterRangeStep.forward
  forward_unchecked := U128.Insts.CoreIterRangeStep.forward_unchecked
  backward := U128.Insts.CoreIterRangeStep.backward
  backward_unchecked := U128.Insts.CoreIterRangeStep.backward_unchecked
}

/-- [core_models::iter::range::{impl core_models::iter::range::Step for i128}::steps_between]:
    Source: 'core-models/src/core/iter.rs', lines 1274:20-1290:21
    Visibility: public -/
def I128.Insts.CoreIterRangeStep.steps_between
  (start : Std.I128) («end» : Std.I128) :
  RustM (Std.Usize × (option.Option Std.Usize))
  := do
  if start <= «end»
  then
    let o ← num.I128.checked_sub «end» start
    match o with
    | option.Option.Some result1 =>
      let r ←
        Usize.Insts.CoreConvertTryFromI128TryFromIntError.try_from
          result1
      match r with
      | core.result.Result.Ok steps => ok (steps, option.Option.Some steps)
      | core.result.Result.Err _ => ok (core.num.Usize.MAX, option.Option.None)
    | option.Option.None => ok (core.num.Usize.MAX, option.Option.None)
  else ok (0#usize, option.Option.None)

/-- Trait implementation: [core_models::iter::range::{impl core_models::iter::range::Step for i128}]
    Source: 'core-models/src/core/iter.rs', lines 1270:16-1299:17 -/
@[reducible]
def I128.Insts.CoreIterRangeStep : iter.range.Step Std.I128 := {
  cloneCloneInst := I128.Insts.CoreCloneClone
  corecmpPartialOrdInst := core.I128.Insts.CoreCmpPartialOrdI128
  steps_between := I128.Insts.CoreIterRangeStep.steps_between
  forward_checked := I128.Insts.CoreIterRangeStep.forward_checked
  backward_checked := I128.Insts.CoreIterRangeStep.backward_checked
  forward := I128.Insts.CoreIterRangeStep.forward
  forward_unchecked := I128.Insts.CoreIterRangeStep.forward_unchecked
  backward := I128.Insts.CoreIterRangeStep.backward
  backward_unchecked := I128.Insts.CoreIterRangeStep.backward_unchecked
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Send for T}]
    Source: 'core-models/src/core/marker.rs', lines 15:0-15:21 -/
@[reducible]
def marker.Send.Blanket (T : Type) : marker.Send T := {
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Sync for T}]
    Source: 'core-models/src/core/marker.rs', lines 16:0-16:21 -/
@[reducible]
def marker.Sync.Blanket (T : Type) : marker.Sync T := {
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Sized for T}]
    Source: 'core-models/src/core/marker.rs', lines 17:0-17:22 -/
@[reducible]
def marker.Sized.Blanket (T : Type) : marker.Sized T := {
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for u8}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def U8.Insts.CoreMarkerCopy : marker.Copy Std.U8 := {
  cloneCloneInst := U8.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for u16}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def U16.Insts.CoreMarkerCopy : marker.Copy Std.U16 := {
  cloneCloneInst := U16.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for u32}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def U32.Insts.CoreMarkerCopy : marker.Copy Std.U32 := {
  cloneCloneInst := U32.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for u64}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def U64.Insts.CoreMarkerCopy : marker.Copy Std.U64 := {
  cloneCloneInst := U64.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for u128}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def U128.Insts.CoreMarkerCopy : marker.Copy Std.U128 := {
  cloneCloneInst := U128.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for usize}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def Usize.Insts.CoreMarkerCopy : marker.Copy Std.Usize := {
  cloneCloneInst := Usize.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for i8}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def I8.Insts.CoreMarkerCopy : marker.Copy Std.I8 := {
  cloneCloneInst := I8.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for i16}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def I16.Insts.CoreMarkerCopy : marker.Copy Std.I16 := {
  cloneCloneInst := I16.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for i32}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def I32.Insts.CoreMarkerCopy : marker.Copy Std.I32 := {
  cloneCloneInst := I32.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for i64}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def I64.Insts.CoreMarkerCopy : marker.Copy Std.I64 := {
  cloneCloneInst := I64.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for i128}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def I128.Insts.CoreMarkerCopy : marker.Copy Std.I128 := {
  cloneCloneInst := I128.Insts.CoreCloneClone
}

/-- Trait implementation: [core_models::marker::{impl core_models::marker::Copy for isize}]
    Source: 'core-models/src/core/marker.rs', lines 25:12-25:31 -/
@[reducible]
def Isize.Insts.CoreMarkerCopy : marker.Copy Std.Isize := {
  cloneCloneInst := Isize.Insts.CoreCloneClone
}

/-- [core_models::mem::drop]:
    Source: 'core-models/src/core/mem.rs', lines 95:0-95:24
    Visibility: public -/
def mem.drop {T : Type} (_x : T) : RustM Unit := do
  ok ()

/-- [core_models::num::error::{impl core_models::cmp::PartialEq<core_models::num::error::TryFromIntError> for core_models::num::error::TryFromIntError}::eq]:
    Source: 'core-models/src/core/num/error.rs', lines 12:4-14:5
    Visibility: public -/
def num.error.TryFromIntError.Insts.CoreCmpPartialEqTryFromIntError.eq
  (self : num.error.TryFromIntError) (_other : num.error.TryFromIntError) :
  RustM Bool
  := do
  ok true

/-- Trait implementation: [core_models::num::error::{impl core_models::cmp::PartialEq<core_models::num::error::TryFromIntError> for core_models::num::error::TryFromIntError}]
    Source: 'core-models/src/core/num/error.rs', lines 11:0-15:1 -/
@[reducible]
impl_def num.error.TryFromIntError.Insts.CoreCmpPartialEqTryFromIntError
  : cmp.PartialEq num.error.TryFromIntError num.error.TryFromIntError := {
  eq :=
    num.error.TryFromIntError.Insts.CoreCmpPartialEqTryFromIntError.eq
  ne := cmp.PartialEq.ne.default
    num.error.TryFromIntError.Insts.CoreCmpPartialEqTryFromIntError
}

/-
/-- [core_models::num::{core_models::num::u128}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 25:12-25:37
    Visibility: public -/
@[global_simps, irreducible] def num.U128.MIN : Std.U128 := 0#u128
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::num::{core_models::num::u8}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 29:12-29:57
    Visibility: public -/
@[global_simps, irreducible] def num.U8.BITS : Std.U32 := 8#u32

/-- [core_models::num::{core_models::num::u16}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 29:12-29:57
    Visibility: public -/
@[global_simps, irreducible] def num.U16.BITS : Std.U32 := 16#u32

/-- [core_models::num::{core_models::num::u32}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 29:12-29:57
    Visibility: public -/
@[global_simps, irreducible] def num.U32.BITS : Std.U32 := 32#u32

/-- [core_models::num::{core_models::num::u64}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 29:12-29:57
    Visibility: public -/
@[global_simps, irreducible] def num.U64.BITS : Std.U32 := 64#u32

/-- [core_models::num::{core_models::num::u128}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 29:12-29:57
    Visibility: public -/
@[global_simps, irreducible] def num.U128.BITS : Std.U32 := 128#u32

/-- [core_models::num::{core_models::num::usize}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 29:12-29:57
    Visibility: public -/
@[global_simps, irreducible] def num.Usize.BITS : Std.U32 := 64#u32

/-- [core_models::num::{core_models::num::u8}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 31:12-33:13
    Visibility: public -/
def num.U8.wrapping_add (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.wrapping_add_u8 x y

/-- [core_models::num::{core_models::num::u16}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 31:12-33:13
    Visibility: public -/
def num.U16.wrapping_add (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.wrapping_add_u16 x y

/-- [core_models::num::{core_models::num::u32}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 31:12-33:13
    Visibility: public -/
def num.U32.wrapping_add (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.wrapping_add_u32 x y

/-- [core_models::num::{core_models::num::u64}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 31:12-33:13
    Visibility: public -/
def num.U64.wrapping_add (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.wrapping_add_u64 x y

/-- [core_models::num::{core_models::num::u128}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 31:12-33:13
    Visibility: public -/
def num.U128.wrapping_add (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.wrapping_add_u128 x y

/-- [core_models::num::{core_models::num::usize}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 31:12-33:13
    Visibility: public -/
def num.Usize.wrapping_add
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.wrapping_add_usize x y

/-- [core_models::num::{core_models::num::u8}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 35:12-37:13
    Visibility: public -/
def num.U8.saturating_add (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.saturating_add_u8 x y

/-- [core_models::num::{core_models::num::u16}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 35:12-37:13
    Visibility: public -/
def num.U16.saturating_add (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.saturating_add_u16 x y

/-- [core_models::num::{core_models::num::u32}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 35:12-37:13
    Visibility: public -/
def num.U32.saturating_add (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.saturating_add_u32 x y

/-- [core_models::num::{core_models::num::u64}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 35:12-37:13
    Visibility: public -/
def num.U64.saturating_add (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.saturating_add_u64 x y

/-- [core_models::num::{core_models::num::u128}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 35:12-37:13
    Visibility: public -/
def num.U128.saturating_add
  (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.saturating_add_u128 x y

/-- [core_models::num::{core_models::num::usize}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 35:12-37:13
    Visibility: public -/
def num.Usize.saturating_add
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.saturating_add_usize x y

/-- [core_models::num::{core_models::num::u8}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 57:12-59:13
    Visibility: public -/
def num.U8.wrapping_sub (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.wrapping_sub_u8 x y

/-- [core_models::num::{core_models::num::u16}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 57:12-59:13
    Visibility: public -/
def num.U16.wrapping_sub (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.wrapping_sub_u16 x y

/-- [core_models::num::{core_models::num::u32}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 57:12-59:13
    Visibility: public -/
def num.U32.wrapping_sub (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.wrapping_sub_u32 x y

/-- [core_models::num::{core_models::num::u64}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 57:12-59:13
    Visibility: public -/
def num.U64.wrapping_sub (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.wrapping_sub_u64 x y

/-- [core_models::num::{core_models::num::u128}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 57:12-59:13
    Visibility: public -/
def num.U128.wrapping_sub (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.wrapping_sub_u128 x y

/-- [core_models::num::{core_models::num::usize}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 57:12-59:13
    Visibility: public -/
def num.Usize.wrapping_sub
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.wrapping_sub_usize x y

/-- [core_models::num::{core_models::num::u8}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 61:12-63:13
    Visibility: public -/
def num.U8.saturating_sub (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.saturating_sub_u8 x y

/-- [core_models::num::{core_models::num::u16}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 61:12-63:13
    Visibility: public -/
def num.U16.saturating_sub (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.saturating_sub_u16 x y

/-- [core_models::num::{core_models::num::u32}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 61:12-63:13
    Visibility: public -/
def num.U32.saturating_sub (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.saturating_sub_u32 x y

/-- [core_models::num::{core_models::num::u64}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 61:12-63:13
    Visibility: public -/
def num.U64.saturating_sub (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.saturating_sub_u64 x y

/-- [core_models::num::{core_models::num::u128}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 61:12-63:13
    Visibility: public -/
def num.U128.saturating_sub
  (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.saturating_sub_u128 x y

/-- [core_models::num::{core_models::num::usize}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 61:12-63:13
    Visibility: public -/
def num.Usize.saturating_sub
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.saturating_sub_usize x y

/-- [core_models::num::{core_models::num::u8}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 83:12-85:13
    Visibility: public -/
def num.U8.wrapping_mul (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.wrapping_mul_u8 x y

/-- [core_models::num::{core_models::num::u16}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 83:12-85:13
    Visibility: public -/
def num.U16.wrapping_mul (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.wrapping_mul_u16 x y

/-- [core_models::num::{core_models::num::u32}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 83:12-85:13
    Visibility: public -/
def num.U32.wrapping_mul (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.wrapping_mul_u32 x y

/-- [core_models::num::{core_models::num::u64}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 83:12-85:13
    Visibility: public -/
def num.U64.wrapping_mul (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.wrapping_mul_u64 x y

/-- [core_models::num::{core_models::num::u128}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 83:12-85:13
    Visibility: public -/
def num.U128.wrapping_mul (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.wrapping_mul_u128 x y

/-- [core_models::num::{core_models::num::usize}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 83:12-85:13
    Visibility: public -/
def num.Usize.wrapping_mul
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.wrapping_mul_usize x y

/-- [core_models::num::{core_models::num::u8}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 87:12-89:13
    Visibility: public -/
def num.U8.saturating_mul (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.saturating_mul_u8 x y

/-- [core_models::num::{core_models::num::u16}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 87:12-89:13
    Visibility: public -/
def num.U16.saturating_mul (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.saturating_mul_u16 x y

/-- [core_models::num::{core_models::num::u32}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 87:12-89:13
    Visibility: public -/
def num.U32.saturating_mul (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.saturating_mul_u32 x y

/-- [core_models::num::{core_models::num::u64}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 87:12-89:13
    Visibility: public -/
def num.U64.saturating_mul (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.saturating_mul_u64 x y

/-- [core_models::num::{core_models::num::u128}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 87:12-89:13
    Visibility: public -/
def num.U128.saturating_mul
  (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.saturating_mul_u128 x y

/-- [core_models::num::{core_models::num::usize}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 87:12-89:13
    Visibility: public -/
def num.Usize.saturating_mul
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.saturating_mul_usize x y

/-- [core_models::num::{core_models::num::u8}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 91:12-93:13
    Visibility: public -/
def num.U8.overflowing_mul
  (x : Std.U8) (y : Std.U8) : RustM (Std.U8 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_u8 x y

/-- [core_models::num::{core_models::num::u16}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 91:12-93:13
    Visibility: public -/
def num.U16.overflowing_mul
  (x : Std.U16) (y : Std.U16) : RustM (Std.U16 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_u16 x y

/-- [core_models::num::{core_models::num::u32}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 91:12-93:13
    Visibility: public -/
def num.U32.overflowing_mul
  (x : Std.U32) (y : Std.U32) : RustM (Std.U32 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_u32 x y

/-- [core_models::num::{core_models::num::u64}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 91:12-93:13
    Visibility: public -/
def num.U64.overflowing_mul
  (x : Std.U64) (y : Std.U64) : RustM (Std.U64 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_u64 x y

/-- [core_models::num::{core_models::num::u128}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 91:12-93:13
    Visibility: public -/
def num.U128.overflowing_mul
  (x : Std.U128) (y : Std.U128) : RustM (Std.U128 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_u128 x y

/-- [core_models::num::{core_models::num::usize}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 91:12-93:13
    Visibility: public -/
def num.Usize.overflowing_mul
  (x : Std.Usize) (y : Std.Usize) : RustM (Std.Usize × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_usize x y

/-- [core_models::num::{core_models::num::u8}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 95:12-102:13
    Visibility: public -/
def num.U8.checked_mul
  (x : Std.U8) (y : Std.U8) : RustM (option.Option Std.U8) := do
  let (result1, overflowed) ← num.U8.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u16}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 95:12-102:13
    Visibility: public -/
def num.U16.checked_mul
  (x : Std.U16) (y : Std.U16) : RustM (option.Option Std.U16) := do
  let (result1, overflowed) ← num.U16.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u32}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 95:12-102:13
    Visibility: public -/
def num.U32.checked_mul
  (x : Std.U32) (y : Std.U32) : RustM (option.Option Std.U32) := do
  let (result1, overflowed) ← num.U32.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u64}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 95:12-102:13
    Visibility: public -/
def num.U64.checked_mul
  (x : Std.U64) (y : Std.U64) : RustM (option.Option Std.U64) := do
  let (result1, overflowed) ← num.U64.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u128}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 95:12-102:13
    Visibility: public -/
def num.U128.checked_mul
  (x : Std.U128) (y : Std.U128) : RustM (option.Option Std.U128) := do
  let (result1, overflowed) ← num.U128.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::usize}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 95:12-102:13
    Visibility: public -/
def num.Usize.checked_mul
  (x : Std.Usize) (y : Std.Usize) : RustM (option.Option Std.Usize) := do
  let (result1, overflowed) ← num.Usize.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u8}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 105:12-107:13
    Visibility: public -/
def num.U8.unchecked_mul (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  x * y

/-- [core_models::num::{core_models::num::u16}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 105:12-107:13
    Visibility: public -/
def num.U16.unchecked_mul (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  x * y

/-- [core_models::num::{core_models::num::u32}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 105:12-107:13
    Visibility: public -/
def num.U32.unchecked_mul (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  x * y

/-- [core_models::num::{core_models::num::u64}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 105:12-107:13
    Visibility: public -/
def num.U64.unchecked_mul (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  x * y

/-- [core_models::num::{core_models::num::u128}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 105:12-107:13
    Visibility: public -/
def num.U128.unchecked_mul (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  x * y

/-- [core_models::num::{core_models::num::usize}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 105:12-107:13
    Visibility: public -/
def num.Usize.unchecked_mul
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  x * y

/-- [core_models::num::{core_models::num::u8}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 110:12-112:13
    Visibility: public -/
def num.U8.rem_euclid (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.rem_euclid_u8 x y

/-- [core_models::num::{core_models::num::u16}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 110:12-112:13
    Visibility: public -/
def num.U16.rem_euclid (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.rem_euclid_u16 x y

/-- [core_models::num::{core_models::num::u32}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 110:12-112:13
    Visibility: public -/
def num.U32.rem_euclid (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.rem_euclid_u32 x y

/-- [core_models::num::{core_models::num::u64}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 110:12-112:13
    Visibility: public -/
def num.U64.rem_euclid (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.rem_euclid_u64 x y

/-- [core_models::num::{core_models::num::u128}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 110:12-112:13
    Visibility: public -/
def num.U128.rem_euclid (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.rem_euclid_u128 x y

/-- [core_models::num::{core_models::num::usize}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 110:12-112:13
    Visibility: public -/
def num.Usize.rem_euclid
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.rem_euclid_usize x y

/-- [core_models::num::{core_models::num::u8}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 114:12-116:13
    Visibility: public -/
def num.U8.pow (x : Std.U8) (exp : Std.U32) : RustM Std.U8 := do
  rust_primitives.arithmetic.pow_u8 x exp

/-- [core_models::num::{core_models::num::u16}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 114:12-116:13
    Visibility: public -/
def num.U16.pow (x : Std.U16) (exp : Std.U32) : RustM Std.U16 := do
  rust_primitives.arithmetic.pow_u16 x exp

/-- [core_models::num::{core_models::num::u32}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 114:12-116:13
    Visibility: public -/
def num.U32.pow (x : Std.U32) (exp : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.pow_u32 x exp

/-- [core_models::num::{core_models::num::u64}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 114:12-116:13
    Visibility: public -/
def num.U64.pow (x : Std.U64) (exp : Std.U32) : RustM Std.U64 := do
  rust_primitives.arithmetic.pow_u64 x exp

/-- [core_models::num::{core_models::num::u128}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 114:12-116:13
    Visibility: public -/
def num.U128.pow (x : Std.U128) (exp : Std.U32) : RustM Std.U128 := do
  rust_primitives.arithmetic.pow_u128 x exp

/-- [core_models::num::{core_models::num::usize}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 114:12-116:13
    Visibility: public -/
def num.Usize.pow (x : Std.Usize) (exp : Std.U32) : RustM Std.Usize := do
  rust_primitives.arithmetic.pow_usize x exp

/-- [core_models::num::{core_models::num::u8}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 118:12-120:13
    Visibility: public -/
def num.U8.overflowing_pow
  (x : Std.U8) (exp : Std.U32) : RustM (Std.U8 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_u8 x exp

/-- [core_models::num::{core_models::num::u16}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 118:12-120:13
    Visibility: public -/
def num.U16.overflowing_pow
  (x : Std.U16) (exp : Std.U32) : RustM (Std.U16 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_u16 x exp

/-- [core_models::num::{core_models::num::u32}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 118:12-120:13
    Visibility: public -/
def num.U32.overflowing_pow
  (x : Std.U32) (exp : Std.U32) : RustM (Std.U32 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_u32 x exp

/-- [core_models::num::{core_models::num::u64}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 118:12-120:13
    Visibility: public -/
def num.U64.overflowing_pow
  (x : Std.U64) (exp : Std.U32) : RustM (Std.U64 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_u64 x exp

/-- [core_models::num::{core_models::num::u128}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 118:12-120:13
    Visibility: public -/
def num.U128.overflowing_pow
  (x : Std.U128) (exp : Std.U32) : RustM (Std.U128 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_u128 x exp

/-- [core_models::num::{core_models::num::usize}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 118:12-120:13
    Visibility: public -/
def num.Usize.overflowing_pow
  (x : Std.Usize) (exp : Std.U32) : RustM (Std.Usize × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_usize x exp

/-- [core_models::num::{core_models::num::u8}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 123:12-130:13
    Visibility: public -/
def num.U8.checked_pow
  (x : Std.U8) (exp : Std.U32) : RustM (option.Option Std.U8) := do
  let (result1, overflowed) ← num.U8.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u16}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 123:12-130:13
    Visibility: public -/
def num.U16.checked_pow
  (x : Std.U16) (exp : Std.U32) : RustM (option.Option Std.U16) := do
  let (result1, overflowed) ← num.U16.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u32}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 123:12-130:13
    Visibility: public -/
def num.U32.checked_pow
  (x : Std.U32) (exp : Std.U32) : RustM (option.Option Std.U32) := do
  let (result1, overflowed) ← num.U32.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u64}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 123:12-130:13
    Visibility: public -/
def num.U64.checked_pow
  (x : Std.U64) (exp : Std.U32) : RustM (option.Option Std.U64) := do
  let (result1, overflowed) ← num.U64.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u128}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 123:12-130:13
    Visibility: public -/
def num.U128.checked_pow
  (x : Std.U128) (exp : Std.U32) : RustM (option.Option Std.U128) := do
  let (result1, overflowed) ← num.U128.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::usize}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 123:12-130:13
    Visibility: public -/
def num.Usize.checked_pow
  (x : Std.Usize) (exp : Std.U32) : RustM (option.Option Std.Usize) := do
  let (result1, overflowed) ← num.Usize.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::u8}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 132:12-134:13
    Visibility: public -/
def num.U8.count_ones (x : Std.U8) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_u8 x

/-- [core_models::num::{core_models::num::u16}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 132:12-134:13
    Visibility: public -/
def num.U16.count_ones (x : Std.U16) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_u16 x

/-- [core_models::num::{core_models::num::u32}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 132:12-134:13
    Visibility: public -/
def num.U32.count_ones (x : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_u32 x

/-- [core_models::num::{core_models::num::u64}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 132:12-134:13
    Visibility: public -/
def num.U64.count_ones (x : Std.U64) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_u64 x

/-- [core_models::num::{core_models::num::u128}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 132:12-134:13
    Visibility: public -/
def num.U128.count_ones (x : Std.U128) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_u128 x

/-- [core_models::num::{core_models::num::usize}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 132:12-134:13
    Visibility: public -/
def num.Usize.count_ones (x : Std.Usize) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_usize x

/-- [core_models::num::{core_models::num::u8}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 137:12-139:13
    Visibility: public -/
def num.U8.rotate_right (x : Std.U8) (n : Std.U32) : RustM Std.U8 := do
  rust_primitives.arithmetic.rotate_right_u8 x n

/-- [core_models::num::{core_models::num::u16}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 137:12-139:13
    Visibility: public -/
def num.U16.rotate_right (x : Std.U16) (n : Std.U32) : RustM Std.U16 := do
  rust_primitives.arithmetic.rotate_right_u16 x n

/-- [core_models::num::{core_models::num::u32}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 137:12-139:13
    Visibility: public -/
def num.U32.rotate_right (x : Std.U32) (n : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.rotate_right_u32 x n

/-- [core_models::num::{core_models::num::u64}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 137:12-139:13
    Visibility: public -/
def num.U64.rotate_right (x : Std.U64) (n : Std.U32) : RustM Std.U64 := do
  rust_primitives.arithmetic.rotate_right_u64 x n

/-- [core_models::num::{core_models::num::u128}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 137:12-139:13
    Visibility: public -/
def num.U128.rotate_right (x : Std.U128) (n : Std.U32) : RustM Std.U128 := do
  rust_primitives.arithmetic.rotate_right_u128 x n

/-- [core_models::num::{core_models::num::usize}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 137:12-139:13
    Visibility: public -/
def num.Usize.rotate_right
  (x : Std.Usize) (n : Std.U32) : RustM Std.Usize := do
  rust_primitives.arithmetic.rotate_right_usize x n

/-- [core_models::num::{core_models::num::u8}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 142:12-144:13
    Visibility: public -/
def num.U8.rotate_left (x : Std.U8) (n : Std.U32) : RustM Std.U8 := do
  rust_primitives.arithmetic.rotate_left_u8 x n

/-- [core_models::num::{core_models::num::u16}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 142:12-144:13
    Visibility: public -/
def num.U16.rotate_left (x : Std.U16) (n : Std.U32) : RustM Std.U16 := do
  rust_primitives.arithmetic.rotate_left_u16 x n

/-- [core_models::num::{core_models::num::u32}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 142:12-144:13
    Visibility: public -/
def num.U32.rotate_left (x : Std.U32) (n : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.rotate_left_u32 x n

/-- [core_models::num::{core_models::num::u64}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 142:12-144:13
    Visibility: public -/
def num.U64.rotate_left (x : Std.U64) (n : Std.U32) : RustM Std.U64 := do
  rust_primitives.arithmetic.rotate_left_u64 x n

/-- [core_models::num::{core_models::num::u128}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 142:12-144:13
    Visibility: public -/
def num.U128.rotate_left (x : Std.U128) (n : Std.U32) : RustM Std.U128 := do
  rust_primitives.arithmetic.rotate_left_u128 x n

/-- [core_models::num::{core_models::num::usize}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 142:12-144:13
    Visibility: public -/
def num.Usize.rotate_left (x : Std.Usize) (n : Std.U32) : RustM Std.Usize := do
  rust_primitives.arithmetic.rotate_left_usize x n

/-- [core_models::num::{core_models::num::u8}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 147:12-149:13
    Visibility: public -/
def num.U8.leading_zeros (x : Std.U8) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_u8 x

/-- [core_models::num::{core_models::num::u16}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 147:12-149:13
    Visibility: public -/
def num.U16.leading_zeros (x : Std.U16) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_u16 x

/-- [core_models::num::{core_models::num::u32}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 147:12-149:13
    Visibility: public -/
def num.U32.leading_zeros (x : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_u32 x

/-- [core_models::num::{core_models::num::u64}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 147:12-149:13
    Visibility: public -/
def num.U64.leading_zeros (x : Std.U64) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_u64 x

/-- [core_models::num::{core_models::num::u128}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 147:12-149:13
    Visibility: public -/
def num.U128.leading_zeros (x : Std.U128) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_u128 x

/-- [core_models::num::{core_models::num::usize}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 147:12-149:13
    Visibility: public -/
def num.Usize.leading_zeros (x : Std.Usize) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_usize x

/-- [core_models::num::{core_models::num::u8}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 152:12-154:13
    Visibility: public -/
def num.U8.ilog2 (x : Std.U8) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_u8 x

/-- [core_models::num::{core_models::num::u16}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 152:12-154:13
    Visibility: public -/
def num.U16.ilog2 (x : Std.U16) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_u16 x

/-- [core_models::num::{core_models::num::u32}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 152:12-154:13
    Visibility: public -/
def num.U32.ilog2 (x : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_u32 x

/-- [core_models::num::{core_models::num::u64}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 152:12-154:13
    Visibility: public -/
def num.U64.ilog2 (x : Std.U64) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_u64 x

/-- [core_models::num::{core_models::num::u128}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 152:12-154:13
    Visibility: public -/
def num.U128.ilog2 (x : Std.U128) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_u128 x

/-- [core_models::num::{core_models::num::usize}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 152:12-154:13
    Visibility: public -/
def num.Usize.ilog2 (x : Std.Usize) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_usize x

/-- [core_models::num::{core_models::num::u8}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 173:12-175:13
    Visibility: public -/
def num.U8.from_be_bytes (bytes : Array Std.U8 1#usize) : RustM Std.U8 := do
  rust_primitives.arithmetic.from_be_bytes_u8 bytes

/-- [core_models::num::{core_models::num::u16}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 173:12-175:13
    Visibility: public -/
def num.U16.from_be_bytes (bytes : Array Std.U8 2#usize) : RustM Std.U16 := do
  rust_primitives.arithmetic.from_be_bytes_u16 bytes

/-- [core_models::num::{core_models::num::u32}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 173:12-175:13
    Visibility: public -/
def num.U32.from_be_bytes (bytes : Array Std.U8 4#usize) : RustM Std.U32 := do
  rust_primitives.arithmetic.from_be_bytes_u32 bytes

/-- [core_models::num::{core_models::num::u64}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 173:12-175:13
    Visibility: public -/
def num.U64.from_be_bytes (bytes : Array Std.U8 8#usize) : RustM Std.U64 := do
  rust_primitives.arithmetic.from_be_bytes_u64 bytes

/-- [core_models::num::{core_models::num::u128}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 173:12-175:13
    Visibility: public -/
def num.U128.from_be_bytes
  (bytes : Array Std.U8 16#usize) : RustM Std.U128 := do
  rust_primitives.arithmetic.from_be_bytes_u128 bytes

/-- [core_models::num::{core_models::num::usize}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 173:12-175:13
    Visibility: public -/
def num.Usize.from_be_bytes
  (bytes : Array Std.U8 8#usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.from_be_bytes_usize bytes

/-- [core_models::num::{core_models::num::u8}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 178:12-180:13
    Visibility: public -/
def num.U8.from_le_bytes (bytes : Array Std.U8 1#usize) : RustM Std.U8 := do
  rust_primitives.arithmetic.from_le_bytes_u8 bytes

/-- [core_models::num::{core_models::num::u16}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 178:12-180:13
    Visibility: public -/
def num.U16.from_le_bytes (bytes : Array Std.U8 2#usize) : RustM Std.U16 := do
  rust_primitives.arithmetic.from_le_bytes_u16 bytes

/-- [core_models::num::{core_models::num::u32}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 178:12-180:13
    Visibility: public -/
def num.U32.from_le_bytes (bytes : Array Std.U8 4#usize) : RustM Std.U32 := do
  rust_primitives.arithmetic.from_le_bytes_u32 bytes

/-- [core_models::num::{core_models::num::u64}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 178:12-180:13
    Visibility: public -/
def num.U64.from_le_bytes (bytes : Array Std.U8 8#usize) : RustM Std.U64 := do
  rust_primitives.arithmetic.from_le_bytes_u64 bytes

/-- [core_models::num::{core_models::num::u128}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 178:12-180:13
    Visibility: public -/
def num.U128.from_le_bytes
  (bytes : Array Std.U8 16#usize) : RustM Std.U128 := do
  rust_primitives.arithmetic.from_le_bytes_u128 bytes

/-- [core_models::num::{core_models::num::usize}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 178:12-180:13
    Visibility: public -/
def num.Usize.from_le_bytes
  (bytes : Array Std.U8 8#usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.from_le_bytes_usize bytes

/-- [core_models::num::{core_models::num::u8}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 183:12-185:13
    Visibility: public -/
def num.U8.to_be_bytes (bytes : Std.U8) : RustM (Array Std.U8 1#usize) := do
  rust_primitives.arithmetic.to_be_bytes_u8 bytes

/-- [core_models::num::{core_models::num::u16}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 183:12-185:13
    Visibility: public -/
def num.U16.to_be_bytes (bytes : Std.U16) : RustM (Array Std.U8 2#usize) := do
  rust_primitives.arithmetic.to_be_bytes_u16 bytes

/-- [core_models::num::{core_models::num::u32}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 183:12-185:13
    Visibility: public -/
def num.U32.to_be_bytes (bytes : Std.U32) : RustM (Array Std.U8 4#usize) := do
  rust_primitives.arithmetic.to_be_bytes_u32 bytes

/-- [core_models::num::{core_models::num::u64}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 183:12-185:13
    Visibility: public -/
def num.U64.to_be_bytes (bytes : Std.U64) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_be_bytes_u64 bytes

/-- [core_models::num::{core_models::num::u128}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 183:12-185:13
    Visibility: public -/
def num.U128.to_be_bytes
  (bytes : Std.U128) : RustM (Array Std.U8 16#usize) := do
  rust_primitives.arithmetic.to_be_bytes_u128 bytes

/-- [core_models::num::{core_models::num::usize}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 183:12-185:13
    Visibility: public -/
def num.Usize.to_be_bytes
  (bytes : Std.Usize) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_be_bytes_usize bytes

/-- [core_models::num::{core_models::num::u8}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 188:12-190:13
    Visibility: public -/
def num.U8.to_le_bytes (bytes : Std.U8) : RustM (Array Std.U8 1#usize) := do
  rust_primitives.arithmetic.to_le_bytes_u8 bytes

/-- [core_models::num::{core_models::num::u16}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 188:12-190:13
    Visibility: public -/
def num.U16.to_le_bytes (bytes : Std.U16) : RustM (Array Std.U8 2#usize) := do
  rust_primitives.arithmetic.to_le_bytes_u16 bytes

/-- [core_models::num::{core_models::num::u32}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 188:12-190:13
    Visibility: public -/
def num.U32.to_le_bytes (bytes : Std.U32) : RustM (Array Std.U8 4#usize) := do
  rust_primitives.arithmetic.to_le_bytes_u32 bytes

/-- [core_models::num::{core_models::num::u64}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 188:12-190:13
    Visibility: public -/
def num.U64.to_le_bytes (bytes : Std.U64) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_le_bytes_u64 bytes

/-- [core_models::num::{core_models::num::u128}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 188:12-190:13
    Visibility: public -/
def num.U128.to_le_bytes
  (bytes : Std.U128) : RustM (Array Std.U8 16#usize) := do
  rust_primitives.arithmetic.to_le_bytes_u128 bytes

/-- [core_models::num::{core_models::num::usize}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 188:12-190:13
    Visibility: public -/
def num.Usize.to_le_bytes
  (bytes : Std.Usize) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_le_bytes_usize bytes

/-- [core_models::num::{core_models::num::u8}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 192:12-198:13
    Visibility: public -/
def num.U8.checked_div
  (x : Std.U8) (y : Std.U8) : RustM (option.Option Std.U8) := do
  if y = 0#u8
  then ok option.Option.None
  else let i ← x / y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u16}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 192:12-198:13
    Visibility: public -/
def num.U16.checked_div
  (x : Std.U16) (y : Std.U16) : RustM (option.Option Std.U16) := do
  if y = 0#u16
  then ok option.Option.None
  else let i ← x / y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u32}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 192:12-198:13
    Visibility: public -/
def num.U32.checked_div
  (x : Std.U32) (y : Std.U32) : RustM (option.Option Std.U32) := do
  if y = 0#u32
  then ok option.Option.None
  else let i ← x / y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u64}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 192:12-198:13
    Visibility: public -/
def num.U64.checked_div
  (x : Std.U64) (y : Std.U64) : RustM (option.Option Std.U64) := do
  if y = 0#u64
  then ok option.Option.None
  else let i ← x / y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u128}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 192:12-198:13
    Visibility: public -/
def num.U128.checked_div
  (x : Std.U128) (y : Std.U128) : RustM (option.Option Std.U128) := do
  if y = 0#u128
  then ok option.Option.None
  else let i ← x / y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::usize}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 192:12-198:13
    Visibility: public -/
def num.Usize.checked_div
  (x : Std.Usize) (y : Std.Usize) : RustM (option.Option Std.Usize) := do
  if y = 0#usize
  then ok option.Option.None
  else let i ← x / y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u8}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 201:12-203:13
    Visibility: public -/
def num.U8.unchecked_div (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  x / y

/-- [core_models::num::{core_models::num::u16}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 201:12-203:13
    Visibility: public -/
def num.U16.unchecked_div (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  x / y

/-- [core_models::num::{core_models::num::u32}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 201:12-203:13
    Visibility: public -/
def num.U32.unchecked_div (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  x / y

/-- [core_models::num::{core_models::num::u64}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 201:12-203:13
    Visibility: public -/
def num.U64.unchecked_div (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  x / y

/-- [core_models::num::{core_models::num::u128}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 201:12-203:13
    Visibility: public -/
def num.U128.unchecked_div (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  x / y

/-- [core_models::num::{core_models::num::usize}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 201:12-203:13
    Visibility: public -/
def num.Usize.unchecked_div
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  x / y

/-- [core_models::num::{core_models::num::u8}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 205:12-211:13
    Visibility: public -/
def num.U8.checked_rem
  (x : Std.U8) (y : Std.U8) : RustM (option.Option Std.U8) := do
  if y = 0#u8
  then ok option.Option.None
  else let i ← x % y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u16}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 205:12-211:13
    Visibility: public -/
def num.U16.checked_rem
  (x : Std.U16) (y : Std.U16) : RustM (option.Option Std.U16) := do
  if y = 0#u16
  then ok option.Option.None
  else let i ← x % y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u32}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 205:12-211:13
    Visibility: public -/
def num.U32.checked_rem
  (x : Std.U32) (y : Std.U32) : RustM (option.Option Std.U32) := do
  if y = 0#u32
  then ok option.Option.None
  else let i ← x % y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u64}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 205:12-211:13
    Visibility: public -/
def num.U64.checked_rem
  (x : Std.U64) (y : Std.U64) : RustM (option.Option Std.U64) := do
  if y = 0#u64
  then ok option.Option.None
  else let i ← x % y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u128}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 205:12-211:13
    Visibility: public -/
def num.U128.checked_rem
  (x : Std.U128) (y : Std.U128) : RustM (option.Option Std.U128) := do
  if y = 0#u128
  then ok option.Option.None
  else let i ← x % y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::usize}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 205:12-211:13
    Visibility: public -/
def num.Usize.checked_rem
  (x : Std.Usize) (y : Std.Usize) : RustM (option.Option Std.Usize) := do
  if y = 0#usize
  then ok option.Option.None
  else let i ← x % y
       ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::u8}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 214:12-216:13
    Visibility: public -/
def num.U8.unchecked_rem (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  x % y

/-- [core_models::num::{core_models::num::u16}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 214:12-216:13
    Visibility: public -/
def num.U16.unchecked_rem (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  x % y

/-- [core_models::num::{core_models::num::u32}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 214:12-216:13
    Visibility: public -/
def num.U32.unchecked_rem (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  x % y

/-- [core_models::num::{core_models::num::u64}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 214:12-216:13
    Visibility: public -/
def num.U64.unchecked_rem (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  x % y

/-- [core_models::num::{core_models::num::u128}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 214:12-216:13
    Visibility: public -/
def num.U128.unchecked_rem (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  x % y

/-- [core_models::num::{core_models::num::usize}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 214:12-216:13
    Visibility: public -/
def num.Usize.unchecked_rem
  (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  x % y

/-- [core_models::num::{core_models::num::u8}::is_power_of_two]:
    Source: 'core-models/src/core/num/mod.rs', lines 218:12-220:13
    Visibility: public -/
def num.U8.is_power_of_two (x : Std.U8) : RustM Bool := do
  if x != 0#u8
  then let i ← x - 1#u8
       let i1 ← lift (x &&& i)
       ok (i1 = 0#u8)
  else ok false

/-- [core_models::num::{core_models::num::u16}::is_power_of_two]:
    Source: 'core-models/src/core/num/mod.rs', lines 218:12-220:13
    Visibility: public -/
def num.U16.is_power_of_two (x : Std.U16) : RustM Bool := do
  if x != 0#u16
  then let i ← x - 1#u16
       let i1 ← lift (x &&& i)
       ok (i1 = 0#u16)
  else ok false

/-- [core_models::num::{core_models::num::u32}::is_power_of_two]:
    Source: 'core-models/src/core/num/mod.rs', lines 218:12-220:13
    Visibility: public -/
def num.U32.is_power_of_two (x : Std.U32) : RustM Bool := do
  if x != 0#u32
  then let i ← x - 1#u32
       let i1 ← lift (x &&& i)
       ok (i1 = 0#u32)
  else ok false

/-- [core_models::num::{core_models::num::u64}::is_power_of_two]:
    Source: 'core-models/src/core/num/mod.rs', lines 218:12-220:13
    Visibility: public -/
def num.U64.is_power_of_two (x : Std.U64) : RustM Bool := do
  if x != 0#u64
  then let i ← x - 1#u64
       let i1 ← lift (x &&& i)
       ok (i1 = 0#u64)
  else ok false

/-- [core_models::num::{core_models::num::u128}::is_power_of_two]:
    Source: 'core-models/src/core/num/mod.rs', lines 218:12-220:13
    Visibility: public -/
def num.U128.is_power_of_two (x : Std.U128) : RustM Bool := do
  if x != 0#u128
  then let i ← x - 1#u128
       let i1 ← lift (x &&& i)
       ok (i1 = 0#u128)
  else ok false

/-- [core_models::num::{core_models::num::usize}::is_power_of_two]:
    Source: 'core-models/src/core/num/mod.rs', lines 218:12-220:13
    Visibility: public -/
def num.Usize.is_power_of_two (x : Std.Usize) : RustM Bool := do
  if x != 0#usize
  then let i ← x - 1#usize
       let i1 ← lift (x &&& i)
       ok (i1 = 0#usize)
  else ok false

/-- [core_models::num::{core_models::num::u8}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 223:12-227:13
    Visibility: public -/
def num.U8.div_ceil (x : Std.U8) (y : Std.U8) : RustM Std.U8 := do
  let d ← x / y
  let r ← x % y
  if r > 0#u8
  then d + 1#u8
  else ok d

/-- [core_models::num::{core_models::num::u16}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 223:12-227:13
    Visibility: public -/
def num.U16.div_ceil (x : Std.U16) (y : Std.U16) : RustM Std.U16 := do
  let d ← x / y
  let r ← x % y
  if r > 0#u16
  then d + 1#u16
  else ok d

/-- [core_models::num::{core_models::num::u32}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 223:12-227:13
    Visibility: public -/
def num.U32.div_ceil (x : Std.U32) (y : Std.U32) : RustM Std.U32 := do
  let d ← x / y
  let r ← x % y
  if r > 0#u32
  then d + 1#u32
  else ok d

/-- [core_models::num::{core_models::num::u64}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 223:12-227:13
    Visibility: public -/
def num.U64.div_ceil (x : Std.U64) (y : Std.U64) : RustM Std.U64 := do
  let d ← x / y
  let r ← x % y
  if r > 0#u64
  then d + 1#u64
  else ok d

/-- [core_models::num::{core_models::num::u128}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 223:12-227:13
    Visibility: public -/
def num.U128.div_ceil (x : Std.U128) (y : Std.U128) : RustM Std.U128 := do
  let d ← x / y
  let r ← x % y
  if r > 0#u128
  then d + 1#u128
  else ok d

/-- [core_models::num::{core_models::num::usize}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 223:12-227:13
    Visibility: public -/
def num.Usize.div_ceil (x : Std.Usize) (y : Std.Usize) : RustM Std.Usize := do
  let d ← x / y
  let r ← x % y
  if r > 0#usize
  then d + 1#usize
  else ok d

/-- [core_models::num::{core_models::num::u8}::is_multiple_of]:
    Source: 'core-models/src/core/num/mod.rs', lines 229:12-235:13
    Visibility: public -/
def num.U8.is_multiple_of (x : Std.U8) (y : Std.U8) : RustM Bool := do
  if y = 0#u8
  then ok (x = 0#u8)
  else let i ← x % y
       ok (i = 0#u8)

/-- [core_models::num::{core_models::num::u16}::is_multiple_of]:
    Source: 'core-models/src/core/num/mod.rs', lines 229:12-235:13
    Visibility: public -/
def num.U16.is_multiple_of (x : Std.U16) (y : Std.U16) : RustM Bool := do
  if y = 0#u16
  then ok (x = 0#u16)
  else let i ← x % y
       ok (i = 0#u16)

/-- [core_models::num::{core_models::num::u32}::is_multiple_of]:
    Source: 'core-models/src/core/num/mod.rs', lines 229:12-235:13
    Visibility: public -/
def num.U32.is_multiple_of (x : Std.U32) (y : Std.U32) : RustM Bool := do
  if y = 0#u32
  then ok (x = 0#u32)
  else let i ← x % y
       ok (i = 0#u32)

/-- [core_models::num::{core_models::num::u64}::is_multiple_of]:
    Source: 'core-models/src/core/num/mod.rs', lines 229:12-235:13
    Visibility: public -/
def num.U64.is_multiple_of (x : Std.U64) (y : Std.U64) : RustM Bool := do
  if y = 0#u64
  then ok (x = 0#u64)
  else let i ← x % y
       ok (i = 0#u64)

/-- [core_models::num::{core_models::num::u128}::is_multiple_of]:
    Source: 'core-models/src/core/num/mod.rs', lines 229:12-235:13
    Visibility: public -/
def num.U128.is_multiple_of (x : Std.U128) (y : Std.U128) : RustM Bool := do
  if y = 0#u128
  then ok (x = 0#u128)
  else let i ← x % y
       ok (i = 0#u128)

/-- [core_models::num::{core_models::num::usize}::is_multiple_of]:
    Source: 'core-models/src/core/num/mod.rs', lines 229:12-235:13
    Visibility: public -/
def num.Usize.is_multiple_of (x : Std.Usize) (y : Std.Usize) : RustM Bool := do
  if y = 0#usize
  then ok (x = 0#usize)
  else let i ← x % y
       ok (i = 0#usize)

/-- [core_models::num::{core_models::num::u8}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 250:12-252:13
    Visibility: public -/
def num.U8.wrapping_neg (x : Std.U8) : RustM Std.U8 := do
  rust_primitives.arithmetic.wrapping_sub_u8 0#u8 x

/-- [core_models::num::{core_models::num::u16}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 250:12-252:13
    Visibility: public -/
def num.U16.wrapping_neg (x : Std.U16) : RustM Std.U16 := do
  rust_primitives.arithmetic.wrapping_sub_u16 0#u16 x

/-- [core_models::num::{core_models::num::u32}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 250:12-252:13
    Visibility: public -/
def num.U32.wrapping_neg (x : Std.U32) : RustM Std.U32 := do
  rust_primitives.arithmetic.wrapping_sub_u32 0#u32 x

/-- [core_models::num::{core_models::num::u64}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 250:12-252:13
    Visibility: public -/
def num.U64.wrapping_neg (x : Std.U64) : RustM Std.U64 := do
  rust_primitives.arithmetic.wrapping_sub_u64 0#u64 x

/-- [core_models::num::{core_models::num::u128}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 250:12-252:13
    Visibility: public -/
def num.U128.wrapping_neg (x : Std.U128) : RustM Std.U128 := do
  rust_primitives.arithmetic.wrapping_sub_u128 0#u128 x

/-- [core_models::num::{core_models::num::usize}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 250:12-252:13
    Visibility: public -/
def num.Usize.wrapping_neg (x : Std.Usize) : RustM Std.Usize := do
  rust_primitives.arithmetic.wrapping_sub_usize 0#usize x

/-
/-- [core_models::num::{core_models::num::i128}::MIN]
    Source: 'core-models/src/core/num/mod.rs', lines 272:12-272:40
    Visibility: public -/
@[global_simps, irreducible]
def num.I128.MIN : Std.I128 := (-170141183460469231731687303715884105728)#i128
-/  -- provided by CoreModels.Core.FunsPrologue

/-- [core_models::num::{core_models::num::i8}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 276:12-276:57
    Visibility: public -/
@[global_simps, irreducible] def num.I8.BITS : Std.U32 := 8#u32

/-- [core_models::num::{core_models::num::i16}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 276:12-276:57
    Visibility: public -/
@[global_simps, irreducible] def num.I16.BITS : Std.U32 := 16#u32

/-- [core_models::num::{core_models::num::i32}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 276:12-276:57
    Visibility: public -/
@[global_simps, irreducible] def num.I32.BITS : Std.U32 := 32#u32

/-- [core_models::num::{core_models::num::i64}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 276:12-276:57
    Visibility: public -/
@[global_simps, irreducible] def num.I64.BITS : Std.U32 := 64#u32

/-- [core_models::num::{core_models::num::i128}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 276:12-276:57
    Visibility: public -/
@[global_simps, irreducible] def num.I128.BITS : Std.U32 := 128#u32

/-- [core_models::num::{core_models::num::isize}::BITS]
    Source: 'core-models/src/core/num/mod.rs', lines 276:12-276:57
    Visibility: public -/
@[global_simps, irreducible] def num.Isize.BITS : Std.U32 := 64#u32

/-- [core_models::num::{core_models::num::i128}::wrapping_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 277:12-279:13
    Visibility: public -/
def num.I128.wrapping_add (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.wrapping_add_i128 x y

/-- [core_models::num::{core_models::num::i8}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 281:12-283:13
    Visibility: public -/
def num.I8.saturating_add (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.saturating_add_i8 x y

/-- [core_models::num::{core_models::num::i16}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 281:12-283:13
    Visibility: public -/
def num.I16.saturating_add (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.saturating_add_i16 x y

/-- [core_models::num::{core_models::num::i32}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 281:12-283:13
    Visibility: public -/
def num.I32.saturating_add (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.saturating_add_i32 x y

/-- [core_models::num::{core_models::num::i64}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 281:12-283:13
    Visibility: public -/
def num.I64.saturating_add (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.saturating_add_i64 x y

/-- [core_models::num::{core_models::num::i128}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 281:12-283:13
    Visibility: public -/
def num.I128.saturating_add
  (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.saturating_add_i128 x y

/-- [core_models::num::{core_models::num::isize}::saturating_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 281:12-283:13
    Visibility: public -/
def num.Isize.saturating_add
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.saturating_add_isize x y

/-- [core_models::num::{core_models::num::i8}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 289:12-296:13
    Visibility: public -/
def num.I8.checked_add
  (x : Std.I8) (y : Std.I8) : RustM (option.Option Std.I8) := do
  let (result1, overflowed) ← num.I8.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i16}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 289:12-296:13
    Visibility: public -/
def num.I16.checked_add
  (x : Std.I16) (y : Std.I16) : RustM (option.Option Std.I16) := do
  let (result1, overflowed) ← num.I16.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i32}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 289:12-296:13
    Visibility: public -/
def num.I32.checked_add
  (x : Std.I32) (y : Std.I32) : RustM (option.Option Std.I32) := do
  let (result1, overflowed) ← num.I32.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i64}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 289:12-296:13
    Visibility: public -/
def num.I64.checked_add
  (x : Std.I64) (y : Std.I64) : RustM (option.Option Std.I64) := do
  let (result1, overflowed) ← num.I64.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::isize}::checked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 289:12-296:13
    Visibility: public -/
def num.Isize.checked_add
  (x : Std.Isize) (y : Std.Isize) : RustM (option.Option Std.Isize) := do
  let (result1, overflowed) ← num.Isize.overflowing_add x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i8}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 299:12-301:13
    Visibility: public -/
def num.I8.unchecked_add (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  x + y

/-- [core_models::num::{core_models::num::i16}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 299:12-301:13
    Visibility: public -/
def num.I16.unchecked_add (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  x + y

/-- [core_models::num::{core_models::num::i32}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 299:12-301:13
    Visibility: public -/
def num.I32.unchecked_add (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  x + y

/-- [core_models::num::{core_models::num::i64}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 299:12-301:13
    Visibility: public -/
def num.I64.unchecked_add (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  x + y

/-- [core_models::num::{core_models::num::i128}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 299:12-301:13
    Visibility: public -/
def num.I128.unchecked_add (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  x + y

/-- [core_models::num::{core_models::num::isize}::unchecked_add]:
    Source: 'core-models/src/core/num/mod.rs', lines 299:12-301:13
    Visibility: public -/
def num.Isize.unchecked_add
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  x + y

/-- [core_models::num::{core_models::num::i128}::wrapping_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 303:12-305:13
    Visibility: public -/
def num.I128.wrapping_sub (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.wrapping_sub_i128 x y

/-- [core_models::num::{core_models::num::i8}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 307:12-309:13
    Visibility: public -/
def num.I8.saturating_sub (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.saturating_sub_i8 x y

/-- [core_models::num::{core_models::num::i16}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 307:12-309:13
    Visibility: public -/
def num.I16.saturating_sub (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.saturating_sub_i16 x y

/-- [core_models::num::{core_models::num::i32}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 307:12-309:13
    Visibility: public -/
def num.I32.saturating_sub (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.saturating_sub_i32 x y

/-- [core_models::num::{core_models::num::i64}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 307:12-309:13
    Visibility: public -/
def num.I64.saturating_sub (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.saturating_sub_i64 x y

/-- [core_models::num::{core_models::num::i128}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 307:12-309:13
    Visibility: public -/
def num.I128.saturating_sub
  (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.saturating_sub_i128 x y

/-- [core_models::num::{core_models::num::isize}::saturating_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 307:12-309:13
    Visibility: public -/
def num.Isize.saturating_sub
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.saturating_sub_isize x y

/-- [core_models::num::{core_models::num::i8}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 315:12-322:13
    Visibility: public -/
def num.I8.checked_sub
  (x : Std.I8) (y : Std.I8) : RustM (option.Option Std.I8) := do
  let (result1, overflowed) ← num.I8.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i16}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 315:12-322:13
    Visibility: public -/
def num.I16.checked_sub
  (x : Std.I16) (y : Std.I16) : RustM (option.Option Std.I16) := do
  let (result1, overflowed) ← num.I16.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i32}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 315:12-322:13
    Visibility: public -/
def num.I32.checked_sub
  (x : Std.I32) (y : Std.I32) : RustM (option.Option Std.I32) := do
  let (result1, overflowed) ← num.I32.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i64}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 315:12-322:13
    Visibility: public -/
def num.I64.checked_sub
  (x : Std.I64) (y : Std.I64) : RustM (option.Option Std.I64) := do
  let (result1, overflowed) ← num.I64.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::isize}::checked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 315:12-322:13
    Visibility: public -/
def num.Isize.checked_sub
  (x : Std.Isize) (y : Std.Isize) : RustM (option.Option Std.Isize) := do
  let (result1, overflowed) ← num.Isize.overflowing_sub x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i8}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 325:12-327:13
    Visibility: public -/
def num.I8.unchecked_sub (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  x - y

/-- [core_models::num::{core_models::num::i16}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 325:12-327:13
    Visibility: public -/
def num.I16.unchecked_sub (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  x - y

/-- [core_models::num::{core_models::num::i32}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 325:12-327:13
    Visibility: public -/
def num.I32.unchecked_sub (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  x - y

/-- [core_models::num::{core_models::num::i64}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 325:12-327:13
    Visibility: public -/
def num.I64.unchecked_sub (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  x - y

/-- [core_models::num::{core_models::num::i128}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 325:12-327:13
    Visibility: public -/
def num.I128.unchecked_sub (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  x - y

/-- [core_models::num::{core_models::num::isize}::unchecked_sub]:
    Source: 'core-models/src/core/num/mod.rs', lines 325:12-327:13
    Visibility: public -/
def num.Isize.unchecked_sub
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  x - y

/-- [core_models::num::{core_models::num::i8}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 349:12-351:13
    Visibility: public -/
def num.I8.wrapping_mul (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.wrapping_mul_i8 x y

/-- [core_models::num::{core_models::num::i16}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 349:12-351:13
    Visibility: public -/
def num.I16.wrapping_mul (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.wrapping_mul_i16 x y

/-- [core_models::num::{core_models::num::i32}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 349:12-351:13
    Visibility: public -/
def num.I32.wrapping_mul (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.wrapping_mul_i32 x y

/-- [core_models::num::{core_models::num::i64}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 349:12-351:13
    Visibility: public -/
def num.I64.wrapping_mul (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.wrapping_mul_i64 x y

/-- [core_models::num::{core_models::num::i128}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 349:12-351:13
    Visibility: public -/
def num.I128.wrapping_mul (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.wrapping_mul_i128 x y

/-- [core_models::num::{core_models::num::isize}::wrapping_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 349:12-351:13
    Visibility: public -/
def num.Isize.wrapping_mul
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.wrapping_mul_isize x y

/-- [core_models::num::{core_models::num::i8}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 353:12-355:13
    Visibility: public -/
def num.I8.saturating_mul (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.saturating_mul_i8 x y

/-- [core_models::num::{core_models::num::i16}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 353:12-355:13
    Visibility: public -/
def num.I16.saturating_mul (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.saturating_mul_i16 x y

/-- [core_models::num::{core_models::num::i32}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 353:12-355:13
    Visibility: public -/
def num.I32.saturating_mul (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.saturating_mul_i32 x y

/-- [core_models::num::{core_models::num::i64}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 353:12-355:13
    Visibility: public -/
def num.I64.saturating_mul (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.saturating_mul_i64 x y

/-- [core_models::num::{core_models::num::i128}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 353:12-355:13
    Visibility: public -/
def num.I128.saturating_mul
  (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.saturating_mul_i128 x y

/-- [core_models::num::{core_models::num::isize}::saturating_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 353:12-355:13
    Visibility: public -/
def num.Isize.saturating_mul
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.saturating_mul_isize x y

/-- [core_models::num::{core_models::num::i8}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 357:12-359:13
    Visibility: public -/
def num.I8.overflowing_mul
  (x : Std.I8) (y : Std.I8) : RustM (Std.I8 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_i8 x y

/-- [core_models::num::{core_models::num::i16}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 357:12-359:13
    Visibility: public -/
def num.I16.overflowing_mul
  (x : Std.I16) (y : Std.I16) : RustM (Std.I16 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_i16 x y

/-- [core_models::num::{core_models::num::i32}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 357:12-359:13
    Visibility: public -/
def num.I32.overflowing_mul
  (x : Std.I32) (y : Std.I32) : RustM (Std.I32 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_i32 x y

/-- [core_models::num::{core_models::num::i64}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 357:12-359:13
    Visibility: public -/
def num.I64.overflowing_mul
  (x : Std.I64) (y : Std.I64) : RustM (Std.I64 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_i64 x y

/-- [core_models::num::{core_models::num::i128}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 357:12-359:13
    Visibility: public -/
def num.I128.overflowing_mul
  (x : Std.I128) (y : Std.I128) : RustM (Std.I128 × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_i128 x y

/-- [core_models::num::{core_models::num::isize}::overflowing_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 357:12-359:13
    Visibility: public -/
def num.Isize.overflowing_mul
  (x : Std.Isize) (y : Std.Isize) : RustM (Std.Isize × Bool) := do
  rust_primitives.arithmetic.overflowing_mul_isize x y

/-- [core_models::num::{core_models::num::i8}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 361:12-368:13
    Visibility: public -/
def num.I8.checked_mul
  (x : Std.I8) (y : Std.I8) : RustM (option.Option Std.I8) := do
  let (result1, overflowed) ← num.I8.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i16}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 361:12-368:13
    Visibility: public -/
def num.I16.checked_mul
  (x : Std.I16) (y : Std.I16) : RustM (option.Option Std.I16) := do
  let (result1, overflowed) ← num.I16.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i32}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 361:12-368:13
    Visibility: public -/
def num.I32.checked_mul
  (x : Std.I32) (y : Std.I32) : RustM (option.Option Std.I32) := do
  let (result1, overflowed) ← num.I32.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i64}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 361:12-368:13
    Visibility: public -/
def num.I64.checked_mul
  (x : Std.I64) (y : Std.I64) : RustM (option.Option Std.I64) := do
  let (result1, overflowed) ← num.I64.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i128}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 361:12-368:13
    Visibility: public -/
def num.I128.checked_mul
  (x : Std.I128) (y : Std.I128) : RustM (option.Option Std.I128) := do
  let (result1, overflowed) ← num.I128.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::isize}::checked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 361:12-368:13
    Visibility: public -/
def num.Isize.checked_mul
  (x : Std.Isize) (y : Std.Isize) : RustM (option.Option Std.Isize) := do
  let (result1, overflowed) ← num.Isize.overflowing_mul x y
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i8}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 371:12-373:13
    Visibility: public -/
def num.I8.unchecked_mul (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  x * y

/-- [core_models::num::{core_models::num::i16}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 371:12-373:13
    Visibility: public -/
def num.I16.unchecked_mul (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  x * y

/-- [core_models::num::{core_models::num::i32}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 371:12-373:13
    Visibility: public -/
def num.I32.unchecked_mul (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  x * y

/-- [core_models::num::{core_models::num::i64}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 371:12-373:13
    Visibility: public -/
def num.I64.unchecked_mul (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  x * y

/-- [core_models::num::{core_models::num::i128}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 371:12-373:13
    Visibility: public -/
def num.I128.unchecked_mul (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  x * y

/-- [core_models::num::{core_models::num::isize}::unchecked_mul]:
    Source: 'core-models/src/core/num/mod.rs', lines 371:12-373:13
    Visibility: public -/
def num.Isize.unchecked_mul
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  x * y

/-- [core_models::num::{core_models::num::i8}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 377:12-379:13
    Visibility: public -/
def num.I8.rem_euclid (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.rem_euclid_i8 x y

/-- [core_models::num::{core_models::num::i16}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 377:12-379:13
    Visibility: public -/
def num.I16.rem_euclid (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.rem_euclid_i16 x y

/-- [core_models::num::{core_models::num::i32}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 377:12-379:13
    Visibility: public -/
def num.I32.rem_euclid (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.rem_euclid_i32 x y

/-- [core_models::num::{core_models::num::i64}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 377:12-379:13
    Visibility: public -/
def num.I64.rem_euclid (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.rem_euclid_i64 x y

/-- [core_models::num::{core_models::num::i128}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 377:12-379:13
    Visibility: public -/
def num.I128.rem_euclid (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.rem_euclid_i128 x y

/-- [core_models::num::{core_models::num::isize}::rem_euclid]:
    Source: 'core-models/src/core/num/mod.rs', lines 377:12-379:13
    Visibility: public -/
def num.Isize.rem_euclid
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.rem_euclid_isize x y

/-- [core_models::num::{core_models::num::i8}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 381:12-383:13
    Visibility: public -/
def num.I8.pow (x : Std.I8) (exp : Std.U32) : RustM Std.I8 := do
  rust_primitives.arithmetic.pow_i8 x exp

/-- [core_models::num::{core_models::num::i16}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 381:12-383:13
    Visibility: public -/
def num.I16.pow (x : Std.I16) (exp : Std.U32) : RustM Std.I16 := do
  rust_primitives.arithmetic.pow_i16 x exp

/-- [core_models::num::{core_models::num::i32}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 381:12-383:13
    Visibility: public -/
def num.I32.pow (x : Std.I32) (exp : Std.U32) : RustM Std.I32 := do
  rust_primitives.arithmetic.pow_i32 x exp

/-- [core_models::num::{core_models::num::i64}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 381:12-383:13
    Visibility: public -/
def num.I64.pow (x : Std.I64) (exp : Std.U32) : RustM Std.I64 := do
  rust_primitives.arithmetic.pow_i64 x exp

/-- [core_models::num::{core_models::num::i128}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 381:12-383:13
    Visibility: public -/
def num.I128.pow (x : Std.I128) (exp : Std.U32) : RustM Std.I128 := do
  rust_primitives.arithmetic.pow_i128 x exp

/-- [core_models::num::{core_models::num::isize}::pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 381:12-383:13
    Visibility: public -/
def num.Isize.pow (x : Std.Isize) (exp : Std.U32) : RustM Std.Isize := do
  rust_primitives.arithmetic.pow_isize x exp

/-- [core_models::num::{core_models::num::i8}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 385:12-387:13
    Visibility: public -/
def num.I8.overflowing_pow
  (x : Std.I8) (exp : Std.U32) : RustM (Std.I8 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_i8 x exp

/-- [core_models::num::{core_models::num::i16}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 385:12-387:13
    Visibility: public -/
def num.I16.overflowing_pow
  (x : Std.I16) (exp : Std.U32) : RustM (Std.I16 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_i16 x exp

/-- [core_models::num::{core_models::num::i32}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 385:12-387:13
    Visibility: public -/
def num.I32.overflowing_pow
  (x : Std.I32) (exp : Std.U32) : RustM (Std.I32 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_i32 x exp

/-- [core_models::num::{core_models::num::i64}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 385:12-387:13
    Visibility: public -/
def num.I64.overflowing_pow
  (x : Std.I64) (exp : Std.U32) : RustM (Std.I64 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_i64 x exp

/-- [core_models::num::{core_models::num::i128}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 385:12-387:13
    Visibility: public -/
def num.I128.overflowing_pow
  (x : Std.I128) (exp : Std.U32) : RustM (Std.I128 × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_i128 x exp

/-- [core_models::num::{core_models::num::isize}::overflowing_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 385:12-387:13
    Visibility: public -/
def num.Isize.overflowing_pow
  (x : Std.Isize) (exp : Std.U32) : RustM (Std.Isize × Bool) := do
  rust_primitives.arithmetic.overflowing_pow_isize x exp

/-- [core_models::num::{core_models::num::i8}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 390:12-397:13
    Visibility: public -/
def num.I8.checked_pow
  (x : Std.I8) (exp : Std.U32) : RustM (option.Option Std.I8) := do
  let (result1, overflowed) ← num.I8.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i16}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 390:12-397:13
    Visibility: public -/
def num.I16.checked_pow
  (x : Std.I16) (exp : Std.U32) : RustM (option.Option Std.I16) := do
  let (result1, overflowed) ← num.I16.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i32}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 390:12-397:13
    Visibility: public -/
def num.I32.checked_pow
  (x : Std.I32) (exp : Std.U32) : RustM (option.Option Std.I32) := do
  let (result1, overflowed) ← num.I32.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i64}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 390:12-397:13
    Visibility: public -/
def num.I64.checked_pow
  (x : Std.I64) (exp : Std.U32) : RustM (option.Option Std.I64) := do
  let (result1, overflowed) ← num.I64.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i128}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 390:12-397:13
    Visibility: public -/
def num.I128.checked_pow
  (x : Std.I128) (exp : Std.U32) : RustM (option.Option Std.I128) := do
  let (result1, overflowed) ← num.I128.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::isize}::checked_pow]:
    Source: 'core-models/src/core/num/mod.rs', lines 390:12-397:13
    Visibility: public -/
def num.Isize.checked_pow
  (x : Std.Isize) (exp : Std.U32) : RustM (option.Option Std.Isize) := do
  let (result1, overflowed) ← num.Isize.overflowing_pow x exp
  if overflowed
  then ok option.Option.None
  else ok (option.Option.Some result1)

/-- [core_models::num::{core_models::num::i8}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 399:12-401:13
    Visibility: public -/
def num.I8.count_ones (x : Std.I8) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_i8 x

/-- [core_models::num::{core_models::num::i16}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 399:12-401:13
    Visibility: public -/
def num.I16.count_ones (x : Std.I16) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_i16 x

/-- [core_models::num::{core_models::num::i32}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 399:12-401:13
    Visibility: public -/
def num.I32.count_ones (x : Std.I32) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_i32 x

/-- [core_models::num::{core_models::num::i64}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 399:12-401:13
    Visibility: public -/
def num.I64.count_ones (x : Std.I64) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_i64 x

/-- [core_models::num::{core_models::num::i128}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 399:12-401:13
    Visibility: public -/
def num.I128.count_ones (x : Std.I128) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_i128 x

/-- [core_models::num::{core_models::num::isize}::count_ones]:
    Source: 'core-models/src/core/num/mod.rs', lines 399:12-401:13
    Visibility: public -/
def num.Isize.count_ones (x : Std.Isize) : RustM Std.U32 := do
  rust_primitives.arithmetic.count_ones_isize x

/-- [core_models::num::{core_models::num::i8}::abs]:
    Source: 'core-models/src/core/num/mod.rs', lines 404:12-406:13
    Visibility: public -/
def num.I8.abs (x : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.abs_i8 x

/-- [core_models::num::{core_models::num::i16}::abs]:
    Source: 'core-models/src/core/num/mod.rs', lines 404:12-406:13
    Visibility: public -/
def num.I16.abs (x : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.abs_i16 x

/-- [core_models::num::{core_models::num::i32}::abs]:
    Source: 'core-models/src/core/num/mod.rs', lines 404:12-406:13
    Visibility: public -/
def num.I32.abs (x : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.abs_i32 x

/-- [core_models::num::{core_models::num::i64}::abs]:
    Source: 'core-models/src/core/num/mod.rs', lines 404:12-406:13
    Visibility: public -/
def num.I64.abs (x : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.abs_i64 x

/-- [core_models::num::{core_models::num::i128}::abs]:
    Source: 'core-models/src/core/num/mod.rs', lines 404:12-406:13
    Visibility: public -/
def num.I128.abs (x : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.abs_i128 x

/-- [core_models::num::{core_models::num::isize}::abs]:
    Source: 'core-models/src/core/num/mod.rs', lines 404:12-406:13
    Visibility: public -/
def num.Isize.abs (x : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.abs_isize x

/-- [core_models::num::{core_models::num::i8}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 409:12-411:13
    Visibility: public -/
def num.I8.rotate_right (x : Std.I8) (n : Std.U32) : RustM Std.I8 := do
  rust_primitives.arithmetic.rotate_right_i8 x n

/-- [core_models::num::{core_models::num::i16}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 409:12-411:13
    Visibility: public -/
def num.I16.rotate_right (x : Std.I16) (n : Std.U32) : RustM Std.I16 := do
  rust_primitives.arithmetic.rotate_right_i16 x n

/-- [core_models::num::{core_models::num::i32}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 409:12-411:13
    Visibility: public -/
def num.I32.rotate_right (x : Std.I32) (n : Std.U32) : RustM Std.I32 := do
  rust_primitives.arithmetic.rotate_right_i32 x n

/-- [core_models::num::{core_models::num::i64}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 409:12-411:13
    Visibility: public -/
def num.I64.rotate_right (x : Std.I64) (n : Std.U32) : RustM Std.I64 := do
  rust_primitives.arithmetic.rotate_right_i64 x n

/-- [core_models::num::{core_models::num::i128}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 409:12-411:13
    Visibility: public -/
def num.I128.rotate_right (x : Std.I128) (n : Std.U32) : RustM Std.I128 := do
  rust_primitives.arithmetic.rotate_right_i128 x n

/-- [core_models::num::{core_models::num::isize}::rotate_right]:
    Source: 'core-models/src/core/num/mod.rs', lines 409:12-411:13
    Visibility: public -/
def num.Isize.rotate_right
  (x : Std.Isize) (n : Std.U32) : RustM Std.Isize := do
  rust_primitives.arithmetic.rotate_right_isize x n

/-- [core_models::num::{core_models::num::i8}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 414:12-416:13
    Visibility: public -/
def num.I8.rotate_left (x : Std.I8) (n : Std.U32) : RustM Std.I8 := do
  rust_primitives.arithmetic.rotate_left_i8 x n

/-- [core_models::num::{core_models::num::i16}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 414:12-416:13
    Visibility: public -/
def num.I16.rotate_left (x : Std.I16) (n : Std.U32) : RustM Std.I16 := do
  rust_primitives.arithmetic.rotate_left_i16 x n

/-- [core_models::num::{core_models::num::i32}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 414:12-416:13
    Visibility: public -/
def num.I32.rotate_left (x : Std.I32) (n : Std.U32) : RustM Std.I32 := do
  rust_primitives.arithmetic.rotate_left_i32 x n

/-- [core_models::num::{core_models::num::i64}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 414:12-416:13
    Visibility: public -/
def num.I64.rotate_left (x : Std.I64) (n : Std.U32) : RustM Std.I64 := do
  rust_primitives.arithmetic.rotate_left_i64 x n

/-- [core_models::num::{core_models::num::i128}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 414:12-416:13
    Visibility: public -/
def num.I128.rotate_left (x : Std.I128) (n : Std.U32) : RustM Std.I128 := do
  rust_primitives.arithmetic.rotate_left_i128 x n

/-- [core_models::num::{core_models::num::isize}::rotate_left]:
    Source: 'core-models/src/core/num/mod.rs', lines 414:12-416:13
    Visibility: public -/
def num.Isize.rotate_left (x : Std.Isize) (n : Std.U32) : RustM Std.Isize := do
  rust_primitives.arithmetic.rotate_left_isize x n

/-- [core_models::num::{core_models::num::i8}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 419:12-421:13
    Visibility: public -/
def num.I8.leading_zeros (x : Std.I8) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_i8 x

/-- [core_models::num::{core_models::num::i16}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 419:12-421:13
    Visibility: public -/
def num.I16.leading_zeros (x : Std.I16) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_i16 x

/-- [core_models::num::{core_models::num::i32}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 419:12-421:13
    Visibility: public -/
def num.I32.leading_zeros (x : Std.I32) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_i32 x

/-- [core_models::num::{core_models::num::i64}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 419:12-421:13
    Visibility: public -/
def num.I64.leading_zeros (x : Std.I64) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_i64 x

/-- [core_models::num::{core_models::num::i128}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 419:12-421:13
    Visibility: public -/
def num.I128.leading_zeros (x : Std.I128) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_i128 x

/-- [core_models::num::{core_models::num::isize}::leading_zeros]:
    Source: 'core-models/src/core/num/mod.rs', lines 419:12-421:13
    Visibility: public -/
def num.Isize.leading_zeros (x : Std.Isize) : RustM Std.U32 := do
  rust_primitives.arithmetic.leading_zeros_isize x

/-- [core_models::num::{core_models::num::i8}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 424:12-426:13
    Visibility: public -/
def num.I8.ilog2 (x : Std.I8) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_i8 x

/-- [core_models::num::{core_models::num::i16}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 424:12-426:13
    Visibility: public -/
def num.I16.ilog2 (x : Std.I16) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_i16 x

/-- [core_models::num::{core_models::num::i32}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 424:12-426:13
    Visibility: public -/
def num.I32.ilog2 (x : Std.I32) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_i32 x

/-- [core_models::num::{core_models::num::i64}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 424:12-426:13
    Visibility: public -/
def num.I64.ilog2 (x : Std.I64) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_i64 x

/-- [core_models::num::{core_models::num::i128}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 424:12-426:13
    Visibility: public -/
def num.I128.ilog2 (x : Std.I128) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_i128 x

/-- [core_models::num::{core_models::num::isize}::ilog2]:
    Source: 'core-models/src/core/num/mod.rs', lines 424:12-426:13
    Visibility: public -/
def num.Isize.ilog2 (x : Std.Isize) : RustM Std.U32 := do
  rust_primitives.arithmetic.ilog2_isize x

/-- [core_models::num::{core_models::num::i8}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 445:12-447:13
    Visibility: public -/
def num.I8.from_be_bytes (bytes : Array Std.U8 1#usize) : RustM Std.I8 := do
  rust_primitives.arithmetic.from_be_bytes_i8 bytes

/-- [core_models::num::{core_models::num::i16}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 445:12-447:13
    Visibility: public -/
def num.I16.from_be_bytes (bytes : Array Std.U8 2#usize) : RustM Std.I16 := do
  rust_primitives.arithmetic.from_be_bytes_i16 bytes

/-- [core_models::num::{core_models::num::i32}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 445:12-447:13
    Visibility: public -/
def num.I32.from_be_bytes (bytes : Array Std.U8 4#usize) : RustM Std.I32 := do
  rust_primitives.arithmetic.from_be_bytes_i32 bytes

/-- [core_models::num::{core_models::num::i64}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 445:12-447:13
    Visibility: public -/
def num.I64.from_be_bytes (bytes : Array Std.U8 8#usize) : RustM Std.I64 := do
  rust_primitives.arithmetic.from_be_bytes_i64 bytes

/-- [core_models::num::{core_models::num::i128}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 445:12-447:13
    Visibility: public -/
def num.I128.from_be_bytes
  (bytes : Array Std.U8 16#usize) : RustM Std.I128 := do
  rust_primitives.arithmetic.from_be_bytes_i128 bytes

/-- [core_models::num::{core_models::num::isize}::from_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 445:12-447:13
    Visibility: public -/
def num.Isize.from_be_bytes
  (bytes : Array Std.U8 8#usize) : RustM Std.Isize := do
  rust_primitives.arithmetic.from_be_bytes_isize bytes

/-- [core_models::num::{core_models::num::i8}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 450:12-452:13
    Visibility: public -/
def num.I8.from_le_bytes (bytes : Array Std.U8 1#usize) : RustM Std.I8 := do
  rust_primitives.arithmetic.from_le_bytes_i8 bytes

/-- [core_models::num::{core_models::num::i16}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 450:12-452:13
    Visibility: public -/
def num.I16.from_le_bytes (bytes : Array Std.U8 2#usize) : RustM Std.I16 := do
  rust_primitives.arithmetic.from_le_bytes_i16 bytes

/-- [core_models::num::{core_models::num::i32}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 450:12-452:13
    Visibility: public -/
def num.I32.from_le_bytes (bytes : Array Std.U8 4#usize) : RustM Std.I32 := do
  rust_primitives.arithmetic.from_le_bytes_i32 bytes

/-- [core_models::num::{core_models::num::i64}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 450:12-452:13
    Visibility: public -/
def num.I64.from_le_bytes (bytes : Array Std.U8 8#usize) : RustM Std.I64 := do
  rust_primitives.arithmetic.from_le_bytes_i64 bytes

/-- [core_models::num::{core_models::num::i128}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 450:12-452:13
    Visibility: public -/
def num.I128.from_le_bytes
  (bytes : Array Std.U8 16#usize) : RustM Std.I128 := do
  rust_primitives.arithmetic.from_le_bytes_i128 bytes

/-- [core_models::num::{core_models::num::isize}::from_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 450:12-452:13
    Visibility: public -/
def num.Isize.from_le_bytes
  (bytes : Array Std.U8 8#usize) : RustM Std.Isize := do
  rust_primitives.arithmetic.from_le_bytes_isize bytes

/-- [core_models::num::{core_models::num::i8}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 455:12-457:13
    Visibility: public -/
def num.I8.to_be_bytes (bytes : Std.I8) : RustM (Array Std.U8 1#usize) := do
  rust_primitives.arithmetic.to_be_bytes_i8 bytes

/-- [core_models::num::{core_models::num::i16}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 455:12-457:13
    Visibility: public -/
def num.I16.to_be_bytes (bytes : Std.I16) : RustM (Array Std.U8 2#usize) := do
  rust_primitives.arithmetic.to_be_bytes_i16 bytes

/-- [core_models::num::{core_models::num::i32}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 455:12-457:13
    Visibility: public -/
def num.I32.to_be_bytes (bytes : Std.I32) : RustM (Array Std.U8 4#usize) := do
  rust_primitives.arithmetic.to_be_bytes_i32 bytes

/-- [core_models::num::{core_models::num::i64}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 455:12-457:13
    Visibility: public -/
def num.I64.to_be_bytes (bytes : Std.I64) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_be_bytes_i64 bytes

/-- [core_models::num::{core_models::num::i128}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 455:12-457:13
    Visibility: public -/
def num.I128.to_be_bytes
  (bytes : Std.I128) : RustM (Array Std.U8 16#usize) := do
  rust_primitives.arithmetic.to_be_bytes_i128 bytes

/-- [core_models::num::{core_models::num::isize}::to_be_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 455:12-457:13
    Visibility: public -/
def num.Isize.to_be_bytes
  (bytes : Std.Isize) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_be_bytes_isize bytes

/-- [core_models::num::{core_models::num::i8}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 460:12-462:13
    Visibility: public -/
def num.I8.to_le_bytes (bytes : Std.I8) : RustM (Array Std.U8 1#usize) := do
  rust_primitives.arithmetic.to_le_bytes_i8 bytes

/-- [core_models::num::{core_models::num::i16}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 460:12-462:13
    Visibility: public -/
def num.I16.to_le_bytes (bytes : Std.I16) : RustM (Array Std.U8 2#usize) := do
  rust_primitives.arithmetic.to_le_bytes_i16 bytes

/-- [core_models::num::{core_models::num::i32}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 460:12-462:13
    Visibility: public -/
def num.I32.to_le_bytes (bytes : Std.I32) : RustM (Array Std.U8 4#usize) := do
  rust_primitives.arithmetic.to_le_bytes_i32 bytes

/-- [core_models::num::{core_models::num::i64}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 460:12-462:13
    Visibility: public -/
def num.I64.to_le_bytes (bytes : Std.I64) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_le_bytes_i64 bytes

/-- [core_models::num::{core_models::num::i128}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 460:12-462:13
    Visibility: public -/
def num.I128.to_le_bytes
  (bytes : Std.I128) : RustM (Array Std.U8 16#usize) := do
  rust_primitives.arithmetic.to_le_bytes_i128 bytes

/-- [core_models::num::{core_models::num::isize}::to_le_bytes]:
    Source: 'core-models/src/core/num/mod.rs', lines 460:12-462:13
    Visibility: public -/
def num.Isize.to_le_bytes
  (bytes : Std.Isize) : RustM (Array Std.U8 8#usize) := do
  rust_primitives.arithmetic.to_le_bytes_isize bytes

/-- [core_models::num::{core_models::num::i8}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 464:12-470:13
    Visibility: public -/
def num.I8.checked_div
  (x : Std.I8) (y : Std.I8) : RustM (option.Option Std.I8) := do
  if y = 0#i8
  then ok option.Option.None
  else
    if x = num.I8.MIN
    then
      if y = (-1)#i8
      then ok option.Option.None
      else let i ← x / y
           ok (option.Option.Some i)
    else let i ← x / y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i16}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 464:12-470:13
    Visibility: public -/
def num.I16.checked_div
  (x : Std.I16) (y : Std.I16) : RustM (option.Option Std.I16) := do
  if y = 0#i16
  then ok option.Option.None
  else
    if x = num.I16.MIN
    then
      if y = (-1)#i16
      then ok option.Option.None
      else let i ← x / y
           ok (option.Option.Some i)
    else let i ← x / y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i32}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 464:12-470:13
    Visibility: public -/
def num.I32.checked_div
  (x : Std.I32) (y : Std.I32) : RustM (option.Option Std.I32) := do
  if y = 0#i32
  then ok option.Option.None
  else
    if x = num.I32.MIN
    then
      if y = (-1)#i32
      then ok option.Option.None
      else let i ← x / y
           ok (option.Option.Some i)
    else let i ← x / y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i64}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 464:12-470:13
    Visibility: public -/
def num.I64.checked_div
  (x : Std.I64) (y : Std.I64) : RustM (option.Option Std.I64) := do
  if y = 0#i64
  then ok option.Option.None
  else
    if x = num.I64.MIN
    then
      if y = (-1)#i64
      then ok option.Option.None
      else let i ← x / y
           ok (option.Option.Some i)
    else let i ← x / y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i128}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 464:12-470:13
    Visibility: public -/
def num.I128.checked_div
  (x : Std.I128) (y : Std.I128) : RustM (option.Option Std.I128) := do
  if y = 0#i128
  then ok option.Option.None
  else
    if x = num.I128.MIN
    then
      if y = (-1)#i128
      then ok option.Option.None
      else let i ← x / y
           ok (option.Option.Some i)
    else let i ← x / y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::isize}::checked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 464:12-470:13
    Visibility: public -/
def num.Isize.checked_div
  (x : Std.Isize) (y : Std.Isize) : RustM (option.Option Std.Isize) := do
  if y = 0#isize
  then ok option.Option.None
  else
    let i := num.Isize.MIN
    if x = i
    then
      if y = (-1)#isize
      then ok option.Option.None
      else let i1 ← x / y
           ok (option.Option.Some i1)
    else let i1 ← x / y
         ok (option.Option.Some i1)

/-- [core_models::num::{core_models::num::i8}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 473:12-475:13
    Visibility: public -/
def num.I8.unchecked_div (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  x / y

/-- [core_models::num::{core_models::num::i16}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 473:12-475:13
    Visibility: public -/
def num.I16.unchecked_div (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  x / y

/-- [core_models::num::{core_models::num::i32}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 473:12-475:13
    Visibility: public -/
def num.I32.unchecked_div (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  x / y

/-- [core_models::num::{core_models::num::i64}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 473:12-475:13
    Visibility: public -/
def num.I64.unchecked_div (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  x / y

/-- [core_models::num::{core_models::num::i128}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 473:12-475:13
    Visibility: public -/
def num.I128.unchecked_div (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  x / y

/-- [core_models::num::{core_models::num::isize}::unchecked_div]:
    Source: 'core-models/src/core/num/mod.rs', lines 473:12-475:13
    Visibility: public -/
def num.Isize.unchecked_div
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  x / y

/-- [core_models::num::{core_models::num::i8}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 477:12-483:13
    Visibility: public -/
def num.I8.checked_rem
  (x : Std.I8) (y : Std.I8) : RustM (option.Option Std.I8) := do
  if y = 0#i8
  then ok option.Option.None
  else
    if x = num.I8.MIN
    then
      if y = (-1)#i8
      then ok option.Option.None
      else let i ← x % y
           ok (option.Option.Some i)
    else let i ← x % y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i16}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 477:12-483:13
    Visibility: public -/
def num.I16.checked_rem
  (x : Std.I16) (y : Std.I16) : RustM (option.Option Std.I16) := do
  if y = 0#i16
  then ok option.Option.None
  else
    if x = num.I16.MIN
    then
      if y = (-1)#i16
      then ok option.Option.None
      else let i ← x % y
           ok (option.Option.Some i)
    else let i ← x % y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i32}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 477:12-483:13
    Visibility: public -/
def num.I32.checked_rem
  (x : Std.I32) (y : Std.I32) : RustM (option.Option Std.I32) := do
  if y = 0#i32
  then ok option.Option.None
  else
    if x = num.I32.MIN
    then
      if y = (-1)#i32
      then ok option.Option.None
      else let i ← x % y
           ok (option.Option.Some i)
    else let i ← x % y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i64}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 477:12-483:13
    Visibility: public -/
def num.I64.checked_rem
  (x : Std.I64) (y : Std.I64) : RustM (option.Option Std.I64) := do
  if y = 0#i64
  then ok option.Option.None
  else
    if x = num.I64.MIN
    then
      if y = (-1)#i64
      then ok option.Option.None
      else let i ← x % y
           ok (option.Option.Some i)
    else let i ← x % y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::i128}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 477:12-483:13
    Visibility: public -/
def num.I128.checked_rem
  (x : Std.I128) (y : Std.I128) : RustM (option.Option Std.I128) := do
  if y = 0#i128
  then ok option.Option.None
  else
    if x = num.I128.MIN
    then
      if y = (-1)#i128
      then ok option.Option.None
      else let i ← x % y
           ok (option.Option.Some i)
    else let i ← x % y
         ok (option.Option.Some i)

/-- [core_models::num::{core_models::num::isize}::checked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 477:12-483:13
    Visibility: public -/
def num.Isize.checked_rem
  (x : Std.Isize) (y : Std.Isize) : RustM (option.Option Std.Isize) := do
  if y = 0#isize
  then ok option.Option.None
  else
    let i := num.Isize.MIN
    if x = i
    then
      if y = (-1)#isize
      then ok option.Option.None
      else let i1 ← x % y
           ok (option.Option.Some i1)
    else let i1 ← x % y
         ok (option.Option.Some i1)

/-- [core_models::num::{core_models::num::i8}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 486:12-488:13
    Visibility: public -/
def num.I8.unchecked_rem (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  x % y

/-- [core_models::num::{core_models::num::i16}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 486:12-488:13
    Visibility: public -/
def num.I16.unchecked_rem (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  x % y

/-- [core_models::num::{core_models::num::i32}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 486:12-488:13
    Visibility: public -/
def num.I32.unchecked_rem (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  x % y

/-- [core_models::num::{core_models::num::i64}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 486:12-488:13
    Visibility: public -/
def num.I64.unchecked_rem (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  x % y

/-- [core_models::num::{core_models::num::i128}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 486:12-488:13
    Visibility: public -/
def num.I128.unchecked_rem (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  x % y

/-- [core_models::num::{core_models::num::isize}::unchecked_rem]:
    Source: 'core-models/src/core/num/mod.rs', lines 486:12-488:13
    Visibility: public -/
def num.Isize.unchecked_rem
  (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  x % y

/-- [core_models::num::{core_models::num::i8}::signum]:
    Source: 'core-models/src/core/num/mod.rs', lines 490:12-498:13
    Visibility: public -/
def num.I8.signum (x : Std.I8) : RustM Std.I8 := do
  if x > 0#i8
  then ok 1#i8
  else if x = 0#i8
       then ok 0#i8
       else ok (-1)#i8

/-- [core_models::num::{core_models::num::i16}::signum]:
    Source: 'core-models/src/core/num/mod.rs', lines 490:12-498:13
    Visibility: public -/
def num.I16.signum (x : Std.I16) : RustM Std.I16 := do
  if x > 0#i16
  then ok 1#i16
  else if x = 0#i16
       then ok 0#i16
       else ok (-1)#i16

/-- [core_models::num::{core_models::num::i32}::signum]:
    Source: 'core-models/src/core/num/mod.rs', lines 490:12-498:13
    Visibility: public -/
def num.I32.signum (x : Std.I32) : RustM Std.I32 := do
  if x > 0#i32
  then ok 1#i32
  else if x = 0#i32
       then ok 0#i32
       else ok (-1)#i32

/-- [core_models::num::{core_models::num::i64}::signum]:
    Source: 'core-models/src/core/num/mod.rs', lines 490:12-498:13
    Visibility: public -/
def num.I64.signum (x : Std.I64) : RustM Std.I64 := do
  if x > 0#i64
  then ok 1#i64
  else if x = 0#i64
       then ok 0#i64
       else ok (-1)#i64

/-- [core_models::num::{core_models::num::i128}::signum]:
    Source: 'core-models/src/core/num/mod.rs', lines 490:12-498:13
    Visibility: public -/
def num.I128.signum (x : Std.I128) : RustM Std.I128 := do
  if x > 0#i128
  then ok 1#i128
  else if x = 0#i128
       then ok 0#i128
       else ok (-1)#i128

/-- [core_models::num::{core_models::num::isize}::signum]:
    Source: 'core-models/src/core/num/mod.rs', lines 490:12-498:13
    Visibility: public -/
def num.Isize.signum (x : Std.Isize) : RustM Std.Isize := do
  if x > 0#isize
  then ok 1#isize
  else if x = 0#isize
       then ok 0#isize
       else ok (-1)#isize

/-- [core_models::num::{core_models::num::i8}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 502:12-511:13
    Visibility: public -/
def num.I8.div_ceil (x : Std.I8) (y : Std.I8) : RustM Std.I8 := do
  let d ← x / y
  let r ← x % y
  if r > 0#i8
  then
    if y > 0#i8
    then d + 1#i8
    else if r < 0#i8
         then if y < 0#i8
              then d + 1#i8
              else ok d
         else ok d
  else if r < 0#i8
       then if y < 0#i8
            then d + 1#i8
            else ok d
       else ok d

/-- [core_models::num::{core_models::num::i16}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 502:12-511:13
    Visibility: public -/
def num.I16.div_ceil (x : Std.I16) (y : Std.I16) : RustM Std.I16 := do
  let d ← x / y
  let r ← x % y
  if r > 0#i16
  then
    if y > 0#i16
    then d + 1#i16
    else if r < 0#i16
         then if y < 0#i16
              then d + 1#i16
              else ok d
         else ok d
  else if r < 0#i16
       then if y < 0#i16
            then d + 1#i16
            else ok d
       else ok d

/-- [core_models::num::{core_models::num::i32}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 502:12-511:13
    Visibility: public -/
def num.I32.div_ceil (x : Std.I32) (y : Std.I32) : RustM Std.I32 := do
  let d ← x / y
  let r ← x % y
  if r > 0#i32
  then
    if y > 0#i32
    then d + 1#i32
    else if r < 0#i32
         then if y < 0#i32
              then d + 1#i32
              else ok d
         else ok d
  else if r < 0#i32
       then if y < 0#i32
            then d + 1#i32
            else ok d
       else ok d

/-- [core_models::num::{core_models::num::i64}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 502:12-511:13
    Visibility: public -/
def num.I64.div_ceil (x : Std.I64) (y : Std.I64) : RustM Std.I64 := do
  let d ← x / y
  let r ← x % y
  if r > 0#i64
  then
    if y > 0#i64
    then d + 1#i64
    else if r < 0#i64
         then if y < 0#i64
              then d + 1#i64
              else ok d
         else ok d
  else if r < 0#i64
       then if y < 0#i64
            then d + 1#i64
            else ok d
       else ok d

/-- [core_models::num::{core_models::num::i128}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 502:12-511:13
    Visibility: public -/
def num.I128.div_ceil (x : Std.I128) (y : Std.I128) : RustM Std.I128 := do
  let d ← x / y
  let r ← x % y
  if r > 0#i128
  then
    if y > 0#i128
    then d + 1#i128
    else if r < 0#i128
         then if y < 0#i128
              then d + 1#i128
              else ok d
         else ok d
  else if r < 0#i128
       then if y < 0#i128
            then d + 1#i128
            else ok d
       else ok d

/-- [core_models::num::{core_models::num::isize}::div_ceil]:
    Source: 'core-models/src/core/num/mod.rs', lines 502:12-511:13
    Visibility: public -/
def num.Isize.div_ceil (x : Std.Isize) (y : Std.Isize) : RustM Std.Isize := do
  let d ← x / y
  let r ← x % y
  if r > 0#isize
  then
    if y > 0#isize
    then d + 1#isize
    else
      if r < 0#isize
      then if y < 0#isize
           then d + 1#isize
           else ok d
      else ok d
  else if r < 0#isize
       then if y < 0#isize
            then d + 1#isize
            else ok d
       else ok d

/-- [core_models::num::{core_models::num::i8}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 526:12-528:13
    Visibility: public -/
def num.I8.wrapping_neg (x : Std.I8) : RustM Std.I8 := do
  rust_primitives.arithmetic.wrapping_sub_i8 0#i8 x

/-- [core_models::num::{core_models::num::i16}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 526:12-528:13
    Visibility: public -/
def num.I16.wrapping_neg (x : Std.I16) : RustM Std.I16 := do
  rust_primitives.arithmetic.wrapping_sub_i16 0#i16 x

/-- [core_models::num::{core_models::num::i32}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 526:12-528:13
    Visibility: public -/
def num.I32.wrapping_neg (x : Std.I32) : RustM Std.I32 := do
  rust_primitives.arithmetic.wrapping_sub_i32 0#i32 x

/-- [core_models::num::{core_models::num::i64}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 526:12-528:13
    Visibility: public -/
def num.I64.wrapping_neg (x : Std.I64) : RustM Std.I64 := do
  rust_primitives.arithmetic.wrapping_sub_i64 0#i64 x

/-- [core_models::num::{core_models::num::i128}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 526:12-528:13
    Visibility: public -/
def num.I128.wrapping_neg (x : Std.I128) : RustM Std.I128 := do
  rust_primitives.arithmetic.wrapping_sub_i128 0#i128 x

/-- [core_models::num::{core_models::num::isize}::wrapping_neg]:
    Source: 'core-models/src/core/num/mod.rs', lines 526:12-528:13
    Visibility: public -/
def num.Isize.wrapping_neg (x : Std.Isize) : RustM Std.Isize := do
  rust_primitives.arithmetic.wrapping_sub_isize 0#isize x

/-- [core_models::num::{impl core_models::default::Default for u8}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def U8.Insts.CoreDefaultDefault.default : RustM Std.U8 := do
  ok 0#u8

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for u8}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def U8.Insts.CoreDefaultDefault : default.Default Std.U8 := {
  default := U8.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for u16}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def U16.Insts.CoreDefaultDefault.default : RustM Std.U16 := do
  ok 0#u16

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for u16}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def U16.Insts.CoreDefaultDefault : default.Default Std.U16 := {
  default := U16.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for u32}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def U32.Insts.CoreDefaultDefault.default : RustM Std.U32 := do
  ok 0#u32

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for u32}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def U32.Insts.CoreDefaultDefault : default.Default Std.U32 := {
  default := U32.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for u64}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def U64.Insts.CoreDefaultDefault.default : RustM Std.U64 := do
  ok 0#u64

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for u64}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def U64.Insts.CoreDefaultDefault : default.Default Std.U64 := {
  default := U64.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for u128}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def U128.Insts.CoreDefaultDefault.default : RustM Std.U128 := do
  ok 0#u128

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for u128}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def U128.Insts.CoreDefaultDefault : default.Default Std.U128 := {
  default := U128.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for usize}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def Usize.Insts.CoreDefaultDefault.default : RustM Std.Usize := do
  ok 0#usize

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for usize}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def Usize.Insts.CoreDefaultDefault : default.Default Std.Usize := {
  default := Usize.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for i8}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def I8.Insts.CoreDefaultDefault.default : RustM Std.I8 := do
  ok 0#i8

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for i8}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def I8.Insts.CoreDefaultDefault : default.Default Std.I8 := {
  default := I8.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for i16}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def I16.Insts.CoreDefaultDefault.default : RustM Std.I16 := do
  ok 0#i16

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for i16}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def I16.Insts.CoreDefaultDefault : default.Default Std.I16 := {
  default := I16.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for i32}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def I32.Insts.CoreDefaultDefault.default : RustM Std.I32 := do
  ok 0#i32

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for i32}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def I32.Insts.CoreDefaultDefault : default.Default Std.I32 := {
  default := I32.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for i64}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def I64.Insts.CoreDefaultDefault.default : RustM Std.I64 := do
  ok 0#i64

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for i64}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def I64.Insts.CoreDefaultDefault : default.Default Std.I64 := {
  default := I64.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for i128}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def I128.Insts.CoreDefaultDefault.default : RustM Std.I128 := do
  ok 0#i128

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for i128}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def I128.Insts.CoreDefaultDefault : default.Default Std.I128 := {
  default := I128.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for isize}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 707:16-709:17
    Visibility: public -/
def Isize.Insts.CoreDefaultDefault.default : RustM Std.Isize := do
  ok 0#isize

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for isize}]
    Source: 'core-models/src/core/num/mod.rs', lines 706:12-710:13 -/
@[reducible]
def Isize.Insts.CoreDefaultDefault : default.Default Std.Isize := {
  default := Isize.Insts.CoreDefaultDefault.default
}

/-- [core_models::num::{impl core_models::default::Default for bool}::default]:
    Source: 'core-models/src/core/num/mod.rs', lines 733:4-735:5
    Visibility: public -/
def Bool.Insts.CoreDefaultDefault.default : RustM Bool := do
  ok false

/-- Trait implementation: [core_models::num::{impl core_models::default::Default for bool}]
    Source: 'core-models/src/core/num/mod.rs', lines 731:0-736:1 -/
@[reducible]
def Bool.Insts.CoreDefaultDefault : default.Default Bool := {
  default := Bool.Insts.CoreDefaultDefault.default
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u8> for u8}::add_assign]:
    Source: 'core-models/src/core/ops.rs', lines 61:16-63:17
    Visibility: public -/
def U8.Insts.CoreOpsArithAddAssignU8.add_assign
  (self : Std.U8) (rhs : Std.U8) : RustM Std.U8 := do
  self + rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u8> for u8}]
    Source: 'core-models/src/core/ops.rs', lines 59:12-64:13 -/
@[reducible]
def U8.Insts.CoreOpsArithAddAssignU8 : ops.arith.AddAssign Std.U8 Std.U8
  := {
  add_assign := U8.Insts.CoreOpsArithAddAssignU8.add_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u16> for u16}::add_assign]:
    Source: 'core-models/src/core/ops.rs', lines 61:16-63:17
    Visibility: public -/
def U16.Insts.CoreOpsArithAddAssignU16.add_assign
  (self : Std.U16) (rhs : Std.U16) : RustM Std.U16 := do
  self + rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u16> for u16}]
    Source: 'core-models/src/core/ops.rs', lines 59:12-64:13 -/
@[reducible]
def U16.Insts.CoreOpsArithAddAssignU16 : ops.arith.AddAssign Std.U16
  Std.U16 := {
  add_assign := U16.Insts.CoreOpsArithAddAssignU16.add_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u32> for u32}::add_assign]:
    Source: 'core-models/src/core/ops.rs', lines 61:16-63:17
    Visibility: public -/
def U32.Insts.CoreOpsArithAddAssignU32.add_assign
  (self : Std.U32) (rhs : Std.U32) : RustM Std.U32 := do
  self + rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u32> for u32}]
    Source: 'core-models/src/core/ops.rs', lines 59:12-64:13 -/
@[reducible]
def U32.Insts.CoreOpsArithAddAssignU32 : ops.arith.AddAssign Std.U32
  Std.U32 := {
  add_assign := U32.Insts.CoreOpsArithAddAssignU32.add_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u64> for u64}::add_assign]:
    Source: 'core-models/src/core/ops.rs', lines 61:16-63:17
    Visibility: public -/
def U64.Insts.CoreOpsArithAddAssignU64.add_assign
  (self : Std.U64) (rhs : Std.U64) : RustM Std.U64 := do
  self + rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::AddAssign<u64> for u64}]
    Source: 'core-models/src/core/ops.rs', lines 59:12-64:13 -/
@[reducible]
def U64.Insts.CoreOpsArithAddAssignU64 : ops.arith.AddAssign Std.U64
  Std.U64 := {
  add_assign := U64.Insts.CoreOpsArithAddAssignU64.add_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u8> for u8}::sub_assign]:
    Source: 'core-models/src/core/ops.rs', lines 69:16-71:17
    Visibility: public -/
def U8.Insts.CoreOpsArithSubAssignU8.sub_assign
  (self : Std.U8) (rhs : Std.U8) : RustM Std.U8 := do
  self - rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u8> for u8}]
    Source: 'core-models/src/core/ops.rs', lines 67:12-72:13 -/
@[reducible]
def U8.Insts.CoreOpsArithSubAssignU8 : ops.arith.SubAssign Std.U8 Std.U8
  := {
  sub_assign := U8.Insts.CoreOpsArithSubAssignU8.sub_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u16> for u16}::sub_assign]:
    Source: 'core-models/src/core/ops.rs', lines 69:16-71:17
    Visibility: public -/
def U16.Insts.CoreOpsArithSubAssignU16.sub_assign
  (self : Std.U16) (rhs : Std.U16) : RustM Std.U16 := do
  self - rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u16> for u16}]
    Source: 'core-models/src/core/ops.rs', lines 67:12-72:13 -/
@[reducible]
def U16.Insts.CoreOpsArithSubAssignU16 : ops.arith.SubAssign Std.U16
  Std.U16 := {
  sub_assign := U16.Insts.CoreOpsArithSubAssignU16.sub_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u32> for u32}::sub_assign]:
    Source: 'core-models/src/core/ops.rs', lines 69:16-71:17
    Visibility: public -/
def U32.Insts.CoreOpsArithSubAssignU32.sub_assign
  (self : Std.U32) (rhs : Std.U32) : RustM Std.U32 := do
  self - rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u32> for u32}]
    Source: 'core-models/src/core/ops.rs', lines 67:12-72:13 -/
@[reducible]
def U32.Insts.CoreOpsArithSubAssignU32 : ops.arith.SubAssign Std.U32
  Std.U32 := {
  sub_assign := U32.Insts.CoreOpsArithSubAssignU32.sub_assign
}

/-- [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u64> for u64}::sub_assign]:
    Source: 'core-models/src/core/ops.rs', lines 69:16-71:17
    Visibility: public -/
def U64.Insts.CoreOpsArithSubAssignU64.sub_assign
  (self : Std.U64) (rhs : Std.U64) : RustM Std.U64 := do
  self - rhs

/-- Trait implementation: [core_models::ops::arith::{impl core_models::ops::arith::SubAssign<u64> for u64}]
    Source: 'core-models/src/core/ops.rs', lines 67:12-72:13 -/
@[reducible]
def U64.Insts.CoreOpsArithSubAssignU64 : ops.arith.SubAssign Std.U64
  Std.U64 := {
  sub_assign := U64.Insts.CoreOpsArithSubAssignU64.sub_assign
}

/-- [core_models::ops::deref::{impl core_models::ops::deref::Deref<T> for &'_0 T}::deref]:
    Source: 'core-models/src/core/ops.rs', lines 290:8-292:9
    Visibility: public -/
def Shared0T.Insts.CoreOpsDerefDeref.deref
  {T : Type} (self : T) : RustM T := do
  ok self

/-- Trait implementation: [core_models::ops::deref::{impl core_models::ops::deref::Deref<T> for &'_0 T}]
    Source: 'core-models/src/core/ops.rs', lines 288:4-293:5 -/
@[reducible]
def Shared0T.Insts.CoreOpsDerefDeref (T : Type) : ops.deref.Deref T T
  := {
  deref := Shared0T.Insts.CoreOpsDerefDeref.deref
}

/-- [core_models::ops::drop::Drop::drop]:
    Source: 'core-models/src/core/ops.rs', lines 310:8-310:29
    Visibility: public -/
@[trait_default]
def ops.drop.Drop.drop.default {Self : Type} (self : Self) : RustM Self := do
  ok self

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u8> for core_models::ops::range::Range<u8>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeU8.Insts.CoreIterTraitsIteratorIteratorU8.next
  (self : ops.range.Range Std.U8) :
  RustM ((option.Option Std.U8) × (ops.range.Range Std.U8))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#u8
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u8> for core_models::ops::range::Range<u8>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeU8.Insts.CoreIterTraitsIteratorIteratorU8 :
  iter.traits.iterator.Iterator (ops.range.Range Std.U8) Std.U8 := {
  next := ops.range.RangeU8.Insts.CoreIterTraitsIteratorIteratorU8.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u16> for core_models::ops::range::Range<u16>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeU16.Insts.CoreIterTraitsIteratorIteratorU16.next
  (self : ops.range.Range Std.U16) :
  RustM ((option.Option Std.U16) × (ops.range.Range Std.U16))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#u16
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u16> for core_models::ops::range::Range<u16>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeU16.Insts.CoreIterTraitsIteratorIteratorU16 :
  iter.traits.iterator.Iterator (ops.range.Range Std.U16) Std.U16 := {
  next :=
    ops.range.RangeU16.Insts.CoreIterTraitsIteratorIteratorU16.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u32> for core_models::ops::range::Range<u32>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeU32.Insts.CoreIterTraitsIteratorIteratorU32.next
  (self : ops.range.Range Std.U32) :
  RustM ((option.Option Std.U32) × (ops.range.Range Std.U32))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#u32
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u32> for core_models::ops::range::Range<u32>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeU32.Insts.CoreIterTraitsIteratorIteratorU32 :
  iter.traits.iterator.Iterator (ops.range.Range Std.U32) Std.U32 := {
  next :=
    ops.range.RangeU32.Insts.CoreIterTraitsIteratorIteratorU32.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u64> for core_models::ops::range::Range<u64>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeU64.Insts.CoreIterTraitsIteratorIteratorU64.next
  (self : ops.range.Range Std.U64) :
  RustM ((option.Option Std.U64) × (ops.range.Range Std.U64))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#u64
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u64> for core_models::ops::range::Range<u64>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeU64.Insts.CoreIterTraitsIteratorIteratorU64 :
  iter.traits.iterator.Iterator (ops.range.Range Std.U64) Std.U64 := {
  next :=
    ops.range.RangeU64.Insts.CoreIterTraitsIteratorIteratorU64.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u128> for core_models::ops::range::Range<u128>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeU128.Insts.CoreIterTraitsIteratorIteratorU128.next
  (self : ops.range.Range Std.U128) :
  RustM ((option.Option Std.U128) × (ops.range.Range Std.U128))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#u128
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<u128> for core_models::ops::range::Range<u128>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeU128.Insts.CoreIterTraitsIteratorIteratorU128 :
  iter.traits.iterator.Iterator (ops.range.Range Std.U128) Std.U128 := {
  next :=
    ops.range.RangeU128.Insts.CoreIterTraitsIteratorIteratorU128.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<usize> for core_models::ops::range::Range<usize>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeUsize.Insts.CoreIterTraitsIteratorIteratorUsize.next
  (self : ops.range.Range Std.Usize) :
  RustM ((option.Option Std.Usize) × (ops.range.Range Std.Usize))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#usize
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<usize> for core_models::ops::range::Range<usize>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeUsize.Insts.CoreIterTraitsIteratorIteratorUsize :
  iter.traits.iterator.Iterator (ops.range.Range Std.Usize) Std.Usize := {
  next :=
    ops.range.RangeUsize.Insts.CoreIterTraitsIteratorIteratorUsize.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i8> for core_models::ops::range::Range<i8>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeI8.Insts.CoreIterTraitsIteratorIteratorI8.next
  (self : ops.range.Range Std.I8) :
  RustM ((option.Option Std.I8) × (ops.range.Range Std.I8))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#i8
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i8> for core_models::ops::range::Range<i8>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeI8.Insts.CoreIterTraitsIteratorIteratorI8 :
  iter.traits.iterator.Iterator (ops.range.Range Std.I8) Std.I8 := {
  next := ops.range.RangeI8.Insts.CoreIterTraitsIteratorIteratorI8.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i16> for core_models::ops::range::Range<i16>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeI16.Insts.CoreIterTraitsIteratorIteratorI16.next
  (self : ops.range.Range Std.I16) :
  RustM ((option.Option Std.I16) × (ops.range.Range Std.I16))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#i16
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i16> for core_models::ops::range::Range<i16>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeI16.Insts.CoreIterTraitsIteratorIteratorI16 :
  iter.traits.iterator.Iterator (ops.range.Range Std.I16) Std.I16 := {
  next :=
    ops.range.RangeI16.Insts.CoreIterTraitsIteratorIteratorI16.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i32> for core_models::ops::range::Range<i32>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeI32.Insts.CoreIterTraitsIteratorIteratorI32.next
  (self : ops.range.Range Std.I32) :
  RustM ((option.Option Std.I32) × (ops.range.Range Std.I32))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#i32
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i32> for core_models::ops::range::Range<i32>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeI32.Insts.CoreIterTraitsIteratorIteratorI32 :
  iter.traits.iterator.Iterator (ops.range.Range Std.I32) Std.I32 := {
  next :=
    ops.range.RangeI32.Insts.CoreIterTraitsIteratorIteratorI32.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i64> for core_models::ops::range::Range<i64>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeI64.Insts.CoreIterTraitsIteratorIteratorI64.next
  (self : ops.range.Range Std.I64) :
  RustM ((option.Option Std.I64) × (ops.range.Range Std.I64))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#i64
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i64> for core_models::ops::range::Range<i64>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeI64.Insts.CoreIterTraitsIteratorIteratorI64 :
  iter.traits.iterator.Iterator (ops.range.Range Std.I64) Std.I64 := {
  next :=
    ops.range.RangeI64.Insts.CoreIterTraitsIteratorIteratorI64.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i128> for core_models::ops::range::Range<i128>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeI128.Insts.CoreIterTraitsIteratorIteratorI128.next
  (self : ops.range.Range Std.I128) :
  RustM ((option.Option Std.I128) × (ops.range.Range Std.I128))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#i128
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<i128> for core_models::ops::range::Range<i128>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeI128.Insts.CoreIterTraitsIteratorIteratorI128 :
  iter.traits.iterator.Iterator (ops.range.Range Std.I128) Std.I128 := {
  next :=
    ops.range.RangeI128.Insts.CoreIterTraitsIteratorIteratorI128.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<isize> for core_models::ops::range::Range<isize>}::next]:
    Source: 'core-models/src/core/ops.rs', lines 345:20-353:21
    Visibility: public -/
def ops.range.RangeIsize.Insts.CoreIterTraitsIteratorIteratorIsize.next
  (self : ops.range.Range Std.Isize) :
  RustM ((option.Option Std.Isize) × (ops.range.Range Std.Isize))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.start + 1#isize
    ok (option.Option.Some self.start, { self with start := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::iterator::Iterator<isize> for core_models::ops::range::Range<isize>}]
    Source: 'core-models/src/core/ops.rs', lines 343:16-354:17 -/
@[reducible]
def ops.range.RangeIsize.Insts.CoreIterTraitsIteratorIteratorIsize :
  iter.traits.iterator.Iterator (ops.range.Range Std.Isize) Std.Isize := {
  next :=
    ops.range.RangeIsize.Insts.CoreIterTraitsIteratorIteratorIsize.next
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u8> for core_models::ops::range::Range<u8>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeU8.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU8.next_back
  (self : ops.range.Range Std.U8) :
  RustM ((option.Option Std.U8) × (ops.range.Range Std.U8))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#u8
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u8> for core_models::ops::range::Range<u8>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeU8.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU8
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.U8)
  Std.U8 := {
  iteratorIteratorInst :=
    ops.range.RangeU8.Insts.CoreIterTraitsIteratorIteratorU8
  next_back :=
    ops.range.RangeU8.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU8.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u16> for core_models::ops::range::Range<u16>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeU16.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU16.next_back
  (self : ops.range.Range Std.U16) :
  RustM ((option.Option Std.U16) × (ops.range.Range Std.U16))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#u16
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u16> for core_models::ops::range::Range<u16>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeU16.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU16
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.U16)
  Std.U16 := {
  iteratorIteratorInst :=
    ops.range.RangeU16.Insts.CoreIterTraitsIteratorIteratorU16
  next_back :=
    ops.range.RangeU16.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU16.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u32> for core_models::ops::range::Range<u32>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeU32.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU32.next_back
  (self : ops.range.Range Std.U32) :
  RustM ((option.Option Std.U32) × (ops.range.Range Std.U32))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#u32
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u32> for core_models::ops::range::Range<u32>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeU32.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU32
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.U32)
  Std.U32 := {
  iteratorIteratorInst :=
    ops.range.RangeU32.Insts.CoreIterTraitsIteratorIteratorU32
  next_back :=
    ops.range.RangeU32.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU32.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u64> for core_models::ops::range::Range<u64>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeU64.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU64.next_back
  (self : ops.range.Range Std.U64) :
  RustM ((option.Option Std.U64) × (ops.range.Range Std.U64))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#u64
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u64> for core_models::ops::range::Range<u64>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeU64.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU64
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.U64)
  Std.U64 := {
  iteratorIteratorInst :=
    ops.range.RangeU64.Insts.CoreIterTraitsIteratorIteratorU64
  next_back :=
    ops.range.RangeU64.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU64.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u128> for core_models::ops::range::Range<u128>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeU128.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU128.next_back
  (self : ops.range.Range Std.U128) :
  RustM ((option.Option Std.U128) × (ops.range.Range Std.U128))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#u128
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<u128> for core_models::ops::range::Range<u128>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeU128.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU128
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.U128)
  Std.U128 := {
  iteratorIteratorInst :=
    ops.range.RangeU128.Insts.CoreIterTraitsIteratorIteratorU128
  next_back :=
    ops.range.RangeU128.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorU128.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<usize> for core_models::ops::range::Range<usize>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeUsize.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorUsize.next_back
  (self : ops.range.Range Std.Usize) :
  RustM ((option.Option Std.Usize) × (ops.range.Range Std.Usize))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#usize
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<usize> for core_models::ops::range::Range<usize>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeUsize.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorUsize
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.Usize)
  Std.Usize := {
  iteratorIteratorInst :=
    ops.range.RangeUsize.Insts.CoreIterTraitsIteratorIteratorUsize
  next_back :=
    ops.range.RangeUsize.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorUsize.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i8> for core_models::ops::range::Range<i8>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeI8.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI8.next_back
  (self : ops.range.Range Std.I8) :
  RustM ((option.Option Std.I8) × (ops.range.Range Std.I8))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#i8
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i8> for core_models::ops::range::Range<i8>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeI8.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI8
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.I8)
  Std.I8 := {
  iteratorIteratorInst :=
    ops.range.RangeI8.Insts.CoreIterTraitsIteratorIteratorI8
  next_back :=
    ops.range.RangeI8.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI8.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i16> for core_models::ops::range::Range<i16>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeI16.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI16.next_back
  (self : ops.range.Range Std.I16) :
  RustM ((option.Option Std.I16) × (ops.range.Range Std.I16))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#i16
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i16> for core_models::ops::range::Range<i16>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeI16.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI16
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.I16)
  Std.I16 := {
  iteratorIteratorInst :=
    ops.range.RangeI16.Insts.CoreIterTraitsIteratorIteratorI16
  next_back :=
    ops.range.RangeI16.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI16.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i32> for core_models::ops::range::Range<i32>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeI32.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI32.next_back
  (self : ops.range.Range Std.I32) :
  RustM ((option.Option Std.I32) × (ops.range.Range Std.I32))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#i32
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i32> for core_models::ops::range::Range<i32>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeI32.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI32
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.I32)
  Std.I32 := {
  iteratorIteratorInst :=
    ops.range.RangeI32.Insts.CoreIterTraitsIteratorIteratorI32
  next_back :=
    ops.range.RangeI32.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI32.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i64> for core_models::ops::range::Range<i64>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeI64.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI64.next_back
  (self : ops.range.Range Std.I64) :
  RustM ((option.Option Std.I64) × (ops.range.Range Std.I64))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#i64
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i64> for core_models::ops::range::Range<i64>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeI64.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI64
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.I64)
  Std.I64 := {
  iteratorIteratorInst :=
    ops.range.RangeI64.Insts.CoreIterTraitsIteratorIteratorI64
  next_back :=
    ops.range.RangeI64.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI64.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i128> for core_models::ops::range::Range<i128>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeI128.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI128.next_back
  (self : ops.range.Range Std.I128) :
  RustM ((option.Option Std.I128) × (ops.range.Range Std.I128))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#i128
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<i128> for core_models::ops::range::Range<i128>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeI128.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI128
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.I128)
  Std.I128 := {
  iteratorIteratorInst :=
    ops.range.RangeI128.Insts.CoreIterTraitsIteratorIteratorI128
  next_back :=
    ops.range.RangeI128.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorI128.next_back
}

/-- [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<isize> for core_models::ops::range::Range<isize>}::next_back]:
    Source: 'core-models/src/core/ops.rs', lines 360:20-367:21
    Visibility: public -/
def
  ops.range.RangeIsize.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorIsize.next_back
  (self : ops.range.Range Std.Isize) :
  RustM ((option.Option Std.Isize) × (ops.range.Range Std.Isize))
  := do
  if self.start >= self.end
  then ok (option.Option.None, self)
  else
    let i ← self.end - 1#isize
    ok (option.Option.Some i, { self with «end» := i })

/-- Trait implementation: [core_models::ops::range::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<isize> for core_models::ops::range::Range<isize>}]
    Source: 'core-models/src/core/ops.rs', lines 359:16-368:17 -/
@[reducible]
def
  ops.range.RangeIsize.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorIsize
  : iter.traits.double_ended.DoubleEndedIterator (ops.range.Range Std.Isize)
  Std.Isize := {
  iteratorIteratorInst :=
    ops.range.RangeIsize.Insts.CoreIterTraitsIteratorIteratorIsize
  next_back :=
    ops.range.RangeIsize.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorIsize.next_back
}

/-- [core_models::option::{core_models::option::Option<T>}::is_some_and]:
    Source: 'core-models/src/core/option.rs', lines 24:4-29:5
    Visibility: public -/
def option.Option.is_some_and
  {T : Type} {F : Type} (coreopsfunctionFnOnceFTupleTBoolInst :
  core.ops.function.FnOnce F T Bool) (self : option.Option T) (f : F) :
  RustM Bool
  := do
  match self with
  | option.Option.Some x => coreopsfunctionFnOnceFTupleTBoolInst.call_once f x
  | option.Option.None => ok false

/-- [core_models::option::{core_models::option::Option<T>}::is_none_or]:
    Source: 'core-models/src/core/option.rs', lines 37:4-42:5
    Visibility: public -/
def option.Option.is_none_or
  {T : Type} {F : Type} (coreopsfunctionFnOnceFTupleTBoolInst :
  core.ops.function.FnOnce F T Bool) (self : option.Option T) (f : F) :
  RustM Bool
  := do
  match self with
  | option.Option.Some x => coreopsfunctionFnOnceFTupleTBoolInst.call_once f x
  | option.Option.None => ok true

/-- [core_models::option::{core_models::option::Option<T>}::as_ref]:
    Source: 'core-models/src/core/option.rs', lines 45:4-50:5
    Visibility: public -/
def option.Option.as_ref
  {T : Type} (self : option.Option T) : RustM (option.Option T) := do
  match self with
  | option.Option.Some _ => ok self
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<T>}::as_mut]:
    Source: 'core-models/src/core/option.rs', lines 56:4-61:5
    Visibility: public -/
def option.Option.as_mut
  {T : Type} (self : option.Option T) :
  RustM ((option.Option T) × (option.Option T → option.Option T))
  := do
  match self with
  | option.Option.Some x =>
    let back :=
      fun o =>
        let t := match o with
                 | option.Option.Some t1 => t1
                 | _ => x
        option.Option.Some t
    ok (self, back)
  | option.Option.None =>
    let back := fun o => option.Option.None
    ok (option.Option.None, back)

/-- [core_models::option::{core_models::option::Option<T>}::unwrap_or_else]:
    Source: 'core-models/src/core/option.rs', lines 90:4-95:5
    Visibility: public -/
def option.Option.unwrap_or_else
  {T : Type} {F : Type} (coreopsfunctionFnOnceFTupleTInst :
  core.ops.function.FnOnce F Unit T) (self : option.Option T) (f : F) :
  RustM T
  := do
  match self with
  | option.Option.Some x => ok x
  | option.Option.None => coreopsfunctionFnOnceFTupleTInst.call_once f ()

/-- [core_models::option::{core_models::option::Option<T>}::unwrap_or_default]:
    Source: 'core-models/src/core/option.rs', lines 98:4-106:5
    Visibility: public -/
def option.Option.unwrap_or_default
  {T : Type} (defaultDefaultInst : default.Default T) (self : option.Option T)
  :
  RustM T
  := do
  match self with
  | option.Option.Some x => ok x
  | option.Option.None => defaultDefaultInst.default

/-- [core_models::option::{core_models::option::Option<T>}::map]:
    Source: 'core-models/src/core/option.rs', lines 109:4-117:5
    Visibility: public -/
def option.Option.map
  {T : Type} {U : Type} {F : Type} (coreopsfunctionFnOnceFTupleTUInst :
  core.ops.function.FnOnce F T U) (self : option.Option T) (f : F) :
  RustM (option.Option U)
  := do
  match self with
  | option.Option.Some x =>
    let t ← coreopsfunctionFnOnceFTupleTUInst.call_once f x
    ok (option.Option.Some t)
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<T>}::map_or]:
    Source: 'core-models/src/core/option.rs', lines 120:4-128:5
    Visibility: public -/
def option.Option.map_or
  {T : Type} {U : Type} {F : Type} (coreopsfunctionFnOnceFTupleTUInst :
  core.ops.function.FnOnce F T U) (self : option.Option T) (default1 : U)
  (f : F) :
  RustM U
  := do
  match self with
  | option.Option.Some t => coreopsfunctionFnOnceFTupleTUInst.call_once f t
  | option.Option.None => ok default1

/-- [core_models::option::{core_models::option::Option<T>}::map_or_else]:
    Source: 'core-models/src/core/option.rs', lines 131:4-140:5
    Visibility: public -/
def option.Option.map_or_else
  {T : Type} {U : Type} {D : Type} {F : Type}
  (coreopsfunctionFnOnceFTupleTUInst : core.ops.function.FnOnce F T U)
  (coreopsfunctionFnOnceDTupleUInst : core.ops.function.FnOnce D Unit U)
  (self : option.Option T) (default1 : D) (f : F) :
  RustM U
  := do
  match self with
  | option.Option.Some t => coreopsfunctionFnOnceFTupleTUInst.call_once f t
  | option.Option.None =>
    coreopsfunctionFnOnceDTupleUInst.call_once default1 ()

/-- [core_models::option::{core_models::option::Option<T>}::map_or_default]:
    Source: 'core-models/src/core/option.rs', lines 143:4-152:5
    Visibility: public -/
def option.Option.map_or_default
  {T : Type} {U : Type} {F : Type} (coreopsfunctionFnOnceFTupleTUInst :
  core.ops.function.FnOnce F T U) (defaultDefaultInst : default.Default U)
  (self : option.Option T) (f : F) :
  RustM U
  := do
  match self with
  | option.Option.Some t => coreopsfunctionFnOnceFTupleTUInst.call_once f t
  | option.Option.None => defaultDefaultInst.default

/-- [core_models::option::{core_models::option::Option<T>}::ok_or]:
    Source: 'core-models/src/core/option.rs', lines 155:4-160:5
    Visibility: public -/
def option.Option.ok_or
  {T : Type} {E : Type} (self : option.Option T) (err : E) :
  RustM (result.Result T E)
  := do
  match self with
  | option.Option.Some v => ok (result.Result.Ok v)
  | option.Option.None => ok (result.Result.Err err)

/-- [core_models::option::{core_models::option::Option<T>}::ok_or_else]:
    Source: 'core-models/src/core/option.rs', lines 163:4-168:5
    Visibility: public -/
def option.Option.ok_or_else
  {T : Type} {E : Type} {F : Type} (coreopsfunctionFnOnceFTupleEInst :
  core.ops.function.FnOnce F Unit E) (self : option.Option T) (err : F) :
  RustM (result.Result T E)
  := do
  match self with
  | option.Option.Some v => ok (result.Result.Ok v)
  | option.Option.None =>
    let t ← coreopsfunctionFnOnceFTupleEInst.call_once err ()
    ok (result.Result.Err t)

/-- [core_models::option::{core_models::option::Option<T>}::and_then]:
    Source: 'core-models/src/core/option.rs', lines 171:4-179:5
    Visibility: public -/
def option.Option.and_then
  {T : Type} {U : Type} {F : Type} (coreopsfunctionFnOnceFTupleTOptionInst :
  core.ops.function.FnOnce F T (option.Option U)) (self : option.Option T)
  (f : F) :
  RustM (option.Option U)
  := do
  match self with
  | option.Option.Some x =>
    coreopsfunctionFnOnceFTupleTOptionInst.call_once f x
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<T>}::filter]:
    Source: 'core-models/src/core/option.rs', lines 192:4-203:5
    Visibility: public -/
def option.Option.filter
  {T : Type} {P : Type} (coreopsfunctionFnOncePTupleSharedTBoolInst :
  core.ops.function.FnOnce P T Bool) (self : option.Option T) (predicate : P) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some x =>
    let b ← coreopsfunctionFnOncePTupleSharedTBoolInst.call_once predicate x
    if b
    then ok self
    else ok option.Option.None
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<T>}::or]:
    Source: 'core-models/src/core/option.rs', lines 206:4-211:5
    Visibility: public -/
def option.Option.or
  {T : Type} (self : option.Option T) (optb : option.Option T) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some _ => ok self
  | option.Option.None => ok optb

/-- [core_models::option::{core_models::option::Option<T>}::or_else]:
    Source: 'core-models/src/core/option.rs', lines 214:4-219:5
    Visibility: public -/
def option.Option.or_else
  {T : Type} {F : Type} (coreopsfunctionFnOnceFTupleOptionInst :
  core.ops.function.FnOnce F Unit (option.Option T)) (self : option.Option T)
  (f : F) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some _ => ok self
  | option.Option.None => coreopsfunctionFnOnceFTupleOptionInst.call_once f ()

/-- [core_models::option::{core_models::option::Option<T>}::xor]:
    Source: 'core-models/src/core/option.rs', lines 222:4-228:5
    Visibility: public -/
def option.Option.xor
  {T : Type} (self : option.Option T) (optb : option.Option T) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some _ =>
    match optb with
    | option.Option.Some _ => ok option.Option.None
    | option.Option.None => ok self
  | option.Option.None =>
    match optb with
    | option.Option.Some _ => ok optb
    | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<T>}::zip]:
    Source: 'core-models/src/core/option.rs', lines 231:4-236:5
    Visibility: public -/
def option.Option.zip
  {T : Type} {U : Type} (self : option.Option T) (other : option.Option U) :
  RustM (option.Option (T × U))
  := do
  match self with
  | option.Option.Some a =>
    match other with
    | option.Option.Some b => ok (option.Option.Some (a, b))
    | option.Option.None => ok option.Option.None
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<T>}::inspect]:
    Source: 'core-models/src/core/option.rs', lines 239:4-244:5
    Visibility: public -/
def option.Option.inspect
  {T : Type} {F : Type} (coreopsfunctionFnOnceFTupleSharedTTupleInst :
  core.ops.function.FnOnce F T Unit) (self : option.Option T) (f : F) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some x =>
    coreopsfunctionFnOnceFTupleSharedTTupleInst.call_once f x
    ok self
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{core_models::option::Option<core_models::option::Option<T>>}::flatten]:
    Source: 'core-models/src/core/option.rs', lines 250:4-255:5
    Visibility: public -/
def option.OptionOption.flatten
  {T : Type} (self : option.Option (option.Option T)) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some inner => ok inner
  | option.Option.None => ok option.Option.None

/-- [core_models::option::{impl core_models::default::Default for core_models::option::Option<T>}::default]:
    Source: 'core-models/src/core/option.rs', lines 261:4-263:5
    Visibility: public -/
def option.Option.Insts.CoreDefaultDefault.default
  (T : Type) : RustM (option.Option T) := do
  ok option.Option.None

/-- Trait implementation: [core_models::option::{impl core_models::default::Default for core_models::option::Option<T>}]
    Source: 'core-models/src/core/option.rs', lines 259:0-264:1 -/
@[reducible]
def option.Option.Insts.CoreDefaultDefault (T : Type) : default.Default
  (option.Option T) := {
  default := option.Option.Insts.CoreDefaultDefault.default T
}

/-- [core_models::option::{impl core_models::clone::Clone for core_models::option::Option<T>}::clone]:
    Source: 'core-models/src/core/option.rs', lines 269:4-274:5
    Visibility: public -/
def option.Option.Insts.CoreCloneClone.clone
  {T : Type} (cloneCloneInst : clone.Clone T) (self : option.Option T) :
  RustM (option.Option T)
  := do
  match self with
  | option.Option.Some arg0 =>
    let t ← cloneCloneInst.clone arg0
    ok (option.Option.Some t)
  | option.Option.None => ok option.Option.None

/-- Trait implementation: [core_models::option::{impl core_models::clone::Clone for core_models::option::Option<T>}]
    Source: 'core-models/src/core/option.rs', lines 268:0-275:1 -/
@[reducible]
impl_def option.Option.Insts.CoreCloneClone {T : Type} (cloneCloneInst :
  clone.Clone T) : clone.Clone (option.Option T) := {
  clone := option.Option.Insts.CoreCloneClone.clone cloneCloneInst
  clone_from := clone.Clone.clone_from.default
    (option.Option.Insts.CoreCloneClone cloneCloneInst)
}

/-- [core_models::option::{impl core_models::cmp::PartialEq<core_models::option::Option<T>> for core_models::option::Option<T>}::eq]:
    Source: 'core-models/src/core/option.rs', lines 283:4-289:5
    Visibility: public -/
def option.Option.Insts.CoreCmpPartialEqOption.eq
  {T : Type} (cmpPartialEqInst : cmp.PartialEq T T) (self : option.Option T)
  (other : option.Option T) :
  RustM Bool
  := do
  match self with
  | option.Option.Some a =>
    match other with
    | option.Option.Some b => cmpPartialEqInst.eq a b
    | option.Option.None => ok false
  | option.Option.None =>
    match other with
    | option.Option.Some _ => ok false
    | option.Option.None => ok true

/-- [core_models::option::{impl core_models::cmp::PartialEq<core_models::option::Option<T>> for core_models::option::Option<T>}::ne]:
    Source: 'core-models/src/core/option.rs', lines 280:4-282:5
    Visibility: public -/
def option.Option.Insts.CoreCmpPartialEqOption.ne
  {T : Type} (cmpPartialEqInst : cmp.PartialEq T T) (self : option.Option T)
  (other : option.Option T) :
  RustM Bool
  := do
  let b ←
    option.Option.Insts.CoreCmpPartialEqOption.eq cmpPartialEqInst self
      other
  ok (b = false)

/-- Trait implementation: [core_models::option::{impl core_models::cmp::PartialEq<core_models::option::Option<T>> for core_models::option::Option<T>}]
    Source: 'core-models/src/core/option.rs', lines 278:0-290:1 -/
@[reducible]
def option.Option.Insts.CoreCmpPartialEqOption {T : Type}
  (cmpPartialEqInst : cmp.PartialEq T T) : cmp.PartialEq (option.Option T)
  (option.Option T) := {
  eq := option.Option.Insts.CoreCmpPartialEqOption.eq cmpPartialEqInst
  ne := option.Option.Insts.CoreCmpPartialEqOption.ne cmpPartialEqInst
}

/-- [core_models::option::{impl core_models::ops::try_trait::Try<T, core_models::option::Option<core_models::convert::Infallible>> for core_models::option::Option<T>}::branch]:
    Source: 'core-models/src/core/option.rs', lines 304:4-309:5
    Visibility: public -/
def option.Option.Insts.CoreOpsTry_traitTryTOptionInfallible.branch
  {T : Type} (self : option.Option T) :
  RustM (ops.control_flow.ControlFlow (option.Option convert.Infallible) T)
  := do
  match self with
  | option.Option.Some v => ok (ops.control_flow.ControlFlow.Continue v)
  | option.Option.None =>
    ok (ops.control_flow.ControlFlow.Break option.Option.None)

/-- [core_models::option::{impl core_models::ops::try_trait::Try<T, core_models::option::Option<core_models::convert::Infallible>> for core_models::option::Option<T>}::from_output]:
    Source: 'core-models/src/core/option.rs', lines 300:4-302:5
    Visibility: public -/
def option.Option.Insts.CoreOpsTry_traitTryTOptionInfallible.from_output
  {T : Type} (output : T) : RustM (option.Option T) := do
  ok (option.Option.Some output)

/-- Trait implementation: [core_models::option::{impl core_models::ops::try_trait::Try<T, core_models::option::Option<core_models::convert::Infallible>> for core_models::option::Option<T>}]
    Source: 'core-models/src/core/option.rs', lines 296:0-310:1 -/
@[reducible]
def option.Option.Insts.CoreOpsTry_traitTryTOptionInfallible (T : Type)
  : ops.try_trait.Try (option.Option T) T (option.Option convert.Infallible)
  := {
  from_output :=
    option.Option.Insts.CoreOpsTry_traitTryTOptionInfallible.from_output
  branch :=
    option.Option.Insts.CoreOpsTry_traitTryTOptionInfallible.branch
}

/-- [core_models::option::{impl core_models::ops::try_trait::FromResidual<core_models::option::Option<core_models::convert::Infallible>> for core_models::option::Option<T>}::from_residual]:
    Source: 'core-models/src/core/option.rs', lines 320:4-325:5
    Visibility: public -/
def
  option.Option.Insts.CoreOpsTry_traitFromResidualOptionInfallible.from_residual
  (T : Type) (residual : option.Option convert.Infallible) :
  RustM (option.Option T)
  := do
  match residual with
  | option.Option.Some _ => panicking.internal.panic (option.Option T)
  | option.Option.None => ok option.Option.None

/-- Trait implementation: [core_models::option::{impl core_models::ops::try_trait::FromResidual<core_models::option::Option<core_models::convert::Infallible>> for core_models::option::Option<T>}]
    Source: 'core-models/src/core/option.rs', lines 316:0-326:1 -/
@[reducible]
def option.Option.Insts.CoreOpsTry_traitFromResidualOptionInfallible (T
  : Type) : ops.try_trait.FromResidual (option.Option T) (option.Option
  convert.Infallible) := {
  from_residual :=
    option.Option.Insts.CoreOpsTry_traitFromResidualOptionInfallible.from_residual
    T
}

/-- [core_models::panicking::panic_explicit]:
    Source: 'core-models/src/core/panicking.rs', lines 5:0-7:1
    Visibility: public -/
def panicking.panic_explicit : RustM Never := do
  fail Error.panic

/-- [core_models::panicking::panic]:
    Source: 'core-models/src/core/panicking.rs', lines 11:0-13:1
    Visibility: public -/
def panicking.panic (_msg : Str) : RustM Never := do
  fail Error.panic

/-- [core_models::panicking::panic_fmt]:
    Source: 'core-models/src/core/panicking.rs', lines 17:0-19:1
    Visibility: public -/
def panicking.panic_fmt (_fmt : fmt.Arguments) : RustM Never := do
  fail Error.panic

/-- [core_models::result::{core_models::result::Result<T, E>}::is_ok_and]:
    Source: 'core-models/src/core/result.rs', lines 24:4-29:5
    Visibility: public -/
def result.Result.is_ok_and
  {T : Type} {E : Type} {F : Type} (coreopsfunctionFnOnceFTupleTBoolInst :
  core.ops.function.FnOnce F T Bool) (self : result.Result T E) (f : F) :
  RustM Bool
  := do
  match self with
  | core.result.Result.Ok t => coreopsfunctionFnOnceFTupleTBoolInst.call_once f t
  | core.result.Result.Err _ => Aeneas.Std.RustM.ok false

/-- [core_models::result::{core_models::result::Result<T, E>}::is_err_and]:
    Source: 'core-models/src/core/result.rs', lines 38:4-43:5
    Visibility: public -/
def result.Result.is_err_and
  {T : Type} {E : Type} {F : Type} (coreopsfunctionFnOnceFTupleEBoolInst :
  core.ops.function.FnOnce F E Bool) (self : result.Result T E) (f : F) :
  RustM Bool
  := do
  match self with
  | core.result.Result.Ok _ => Aeneas.Std.RustM.ok false
  | core.result.Result.Err e => coreopsfunctionFnOnceFTupleEBoolInst.call_once f e

/-- [core_models::result::{core_models::result::Result<T, E>}::unwrap_or_else]:
    Source: 'core-models/src/core/result.rs', lines 105:4-110:5
    Visibility: public -/
def result.Result.unwrap_or_else
  {T : Type} {E : Type} {F : Type} (coreopsfunctionFnOnceFTupleETInst :
  core.ops.function.FnOnce F E T) (self : result.Result T E) (op : F) :
  RustM T
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok t
  | core.result.Result.Err e => coreopsfunctionFnOnceFTupleETInst.call_once op e

/-- [core_models::result::{core_models::result::Result<T, E>}::unwrap_or_default]:
    Source: 'core-models/src/core/result.rs', lines 113:4-121:5
    Visibility: public -/
def result.Result.unwrap_or_default
  {T : Type} {E : Type} (defaultDefaultInst : default.Default T)
  (self : result.Result T E) :
  RustM T
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok t
  | core.result.Result.Err _ => defaultDefaultInst.default

/-- [core_models::result::{core_models::result::Result<T, E>}::map]:
    Source: 'core-models/src/core/result.rs', lines 124:4-132:5
    Visibility: public -/
def result.Result.map
  {T : Type} {E : Type} {U : Type} {F : Type}
  (coreopsfunctionFnOnceFTupleTUInst : core.ops.function.FnOnce F T U)
  (self : result.Result T E) (op : F) :
  RustM (result.Result U E)
  := do
  match self with
  | core.result.Result.Ok t =>
    let t1 ← coreopsfunctionFnOnceFTupleTUInst.call_once op t
    Aeneas.Std.RustM.ok (result.Result.Ok t1)
  | core.result.Result.Err e => Aeneas.Std.RustM.ok (result.Result.Err e)

/-- [core_models::result::{core_models::result::Result<T, E>}::map_or]:
    Source: 'core-models/src/core/result.rs', lines 135:4-143:5
    Visibility: public -/
def result.Result.map_or
  {T : Type} {E : Type} {U : Type} {F : Type}
  (coreopsfunctionFnOnceFTupleTUInst : core.ops.function.FnOnce F T U)
  (self : result.Result T E) (default1 : U) (f : F) :
  RustM U
  := do
  match self with
  | core.result.Result.Ok t => coreopsfunctionFnOnceFTupleTUInst.call_once f t
  | core.result.Result.Err _ => Aeneas.Std.RustM.ok default1

/-- [core_models::result::{core_models::result::Result<T, E>}::map_or_else]:
    Source: 'core-models/src/core/result.rs', lines 146:4-155:5
    Visibility: public -/
def result.Result.map_or_else
  {T : Type} {E : Type} {U : Type} {D : Type} {F : Type}
  (coreopsfunctionFnOnceDTupleEUInst : core.ops.function.FnOnce D E U)
  (coreopsfunctionFnOnceFTupleTUInst : core.ops.function.FnOnce F T U)
  (self : result.Result T E) (default1 : D) (f : F) :
  RustM U
  := do
  match self with
  | core.result.Result.Ok t => coreopsfunctionFnOnceFTupleTUInst.call_once f t
  | core.result.Result.Err e =>
    coreopsfunctionFnOnceDTupleEUInst.call_once default1 e

/-- [core_models::result::{core_models::result::Result<T, E>}::inspect]:
    Source: 'core-models/src/core/result.rs', lines 171:4-176:5
    Visibility: public -/
def result.Result.inspect
  {T : Type} {E : Type} {F : Type} (coreopsfunctionFnOnceFTupleSharedTTupleInst
  : core.ops.function.FnOnce F T Unit) (self : result.Result T E) (f : F) :
  RustM (result.Result T E)
  := do
  match self with
  | core.result.Result.Ok t =>
    coreopsfunctionFnOnceFTupleSharedTTupleInst.call_once f t
    Aeneas.Std.RustM.ok self
  | core.result.Result.Err _ => Aeneas.Std.RustM.ok self

/-- [core_models::result::{core_models::result::Result<T, E>}::inspect_err]:
    Source: 'core-models/src/core/result.rs', lines 179:4-184:5
    Visibility: public -/
def result.Result.inspect_err
  {T : Type} {E : Type} {F : Type} (coreopsfunctionFnOnceFTupleSharedETupleInst
  : core.ops.function.FnOnce F E Unit) (self : result.Result T E) (f : F) :
  RustM (result.Result T E)
  := do
  match self with
  | core.result.Result.Ok _ => Aeneas.Std.RustM.ok self
  | core.result.Result.Err e =>
    coreopsfunctionFnOnceFTupleSharedETupleInst.call_once f e
    Aeneas.Std.RustM.ok self

/-- [core_models::result::{core_models::result::Result<T, E>}::and]:
    Source: 'core-models/src/core/result.rs', lines 205:4-210:5
    Visibility: public -/
def result.Result.and
  {T : Type} {E : Type} {U : Type} (self : result.Result T E)
  (res : result.Result U E) :
  RustM (result.Result U E)
  := do
  match self with
  | core.result.Result.Ok _ => Aeneas.Std.RustM.ok res
  | core.result.Result.Err e => Aeneas.Std.RustM.ok (result.Result.Err e)

/-- [core_models::result::{core_models::result::Result<T, E>}::and_then]:
    Source: 'core-models/src/core/result.rs', lines 213:4-221:5
    Visibility: public -/
def result.Result.and_then
  {T : Type} {E : Type} {U : Type} {F : Type}
  (coreopsfunctionFnOnceFTupleTResultInst : core.ops.function.FnOnce F T
  (result.Result U E)) (self : result.Result T E) (op : F) :
  RustM (result.Result U E)
  := do
  match self with
  | core.result.Result.Ok t => coreopsfunctionFnOnceFTupleTResultInst.call_once op t
  | core.result.Result.Err e => Aeneas.Std.RustM.ok (result.Result.Err e)

/-- [core_models::result::{core_models::result::Result<T, E>}::or]:
    Source: 'core-models/src/core/result.rs', lines 224:4-229:5
    Visibility: public -/
def result.Result.or
  {T : Type} {E : Type} {F : Type} (self : result.Result T E)
  (res : result.Result T F) :
  RustM (result.Result T F)
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok (result.Result.Ok t)
  | core.result.Result.Err _ => Aeneas.Std.RustM.ok res

/-- [core_models::result::{core_models::result::Result<T, E>}::or_else]:
    Source: 'core-models/src/core/result.rs', lines 232:4-237:5
    Visibility: public -/
def result.Result.or_else
  {T : Type} {E : Type} {F : Type} {O : Type}
  (coreopsfunctionFnOnceOTupleEResultInst : core.ops.function.FnOnce O E
  (result.Result T F)) (self : result.Result T E) (op : O) :
  RustM (result.Result T F)
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok (result.Result.Ok t)
  | core.result.Result.Err e =>
    coreopsfunctionFnOnceOTupleEResultInst.call_once op e

/-- [core_models::result::{core_models::result::Result<T, E>}::unwrap_or]:
    Source: 'core-models/src/core/result.rs', lines 240:4-245:5
    Visibility: public -/
def result.Result.unwrap_or
  {T : Type} {E : Type} (self : result.Result T E) (default1 : T) :
  RustM T
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok t
  | core.result.Result.Err _ => Aeneas.Std.RustM.ok default1

/-- [core_models::result::{core_models::result::Result<T, E>}::map_err]:
    Source: 'core-models/src/core/result.rs', lines 247:4-255:5
    Visibility: public -/
def result.Result.map_err
  {T : Type} {E : Type} {F : Type} {O : Type}
  (coreopsfunctionFnOnceOTupleEFInst : core.ops.function.FnOnce O E F)
  (self : result.Result T E) (op : O) :
  RustM (result.Result T F)
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok (result.Result.Ok t)
  | core.result.Result.Err e =>
    let t ← coreopsfunctionFnOnceOTupleEFInst.call_once op e
    Aeneas.Std.RustM.ok (result.Result.Err t)

/-- [core_models::result::{core_models::result::Result<T, E>}::expect]:
    Source: 'core-models/src/core/result.rs', lines 266:4-274:5
    Visibility: public -/
def result.Result.expect
  {T : Type} {E : Type} (fmtDebugInst : fmt.Debug E) (self : result.Result T E)
  (_msg : Str) :
  RustM T
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok t
  | core.result.Result.Err _ => panicking.internal.panic T

/-- [core_models::result::{core_models::result::Result<T, E>}::unwrap]:
    Source: 'core-models/src/core/result.rs', lines 278:4-286:5
    Visibility: public -/
def result.Result.unwrap
  {T : Type} {E : Type} (fmtDebugInst : fmt.Debug E) (self : result.Result T E)
  :
  RustM T
  := do
  match self with
  | core.result.Result.Ok t => Aeneas.Std.RustM.ok t
  | core.result.Result.Err _ => panicking.internal.panic T

/-- [core_models::result::{core_models::result::Result<T, E>}::expect_err]:
    Source: 'core-models/src/core/result.rs', lines 290:4-298:5
    Visibility: public -/
def result.Result.expect_err
  {T : Type} {E : Type} (fmtDebugInst : fmt.Debug T) (self : result.Result T E)
  (_msg : Str) :
  RustM E
  := do
  match self with
  | core.result.Result.Ok _ => panicking.internal.panic E
  | core.result.Result.Err e => Aeneas.Std.RustM.ok e

/-- [core_models::result::{core_models::result::Result<T, E>}::unwrap_err]:
    Source: 'core-models/src/core/result.rs', lines 302:4-310:5
    Visibility: public -/
def result.Result.unwrap_err
  {T : Type} {E : Type} (fmtDebugInst : fmt.Debug T) (self : result.Result T E)
  :
  RustM E
  := do
  match self with
  | core.result.Result.Ok _ => panicking.internal.panic E
  | core.result.Result.Err e => Aeneas.Std.RustM.ok e

/-- [core_models::result::{impl core_models::iter::traits::iterator::Iterator<A> for core_models::result::SeqIter<A>}::next]:
    Source: 'core-models/src/core/result.rs', lines 359:4-365:5
    Visibility: public -/
def result.SeqIter.Insts.CoreIterTraitsIteratorIterator.next
  {A : Type} (self : result.SeqIter A) :
  RustM ((option.Option A) × (result.SeqIter A))
  := do
  let i ← rust_primitives.sequence.seq_len self
  if i = 0#usize
  then ok (option.Option.None, self)
  else
    let (t, s) ← rust_primitives.sequence.seq_remove self 0#usize
    ok (option.Option.Some t, s)

/-- Trait implementation: [core_models::result::{impl core_models::iter::traits::iterator::Iterator<A> for core_models::result::SeqIter<A>}]
    Source: 'core-models/src/core/result.rs', lines 356:0-366:1 -/
@[reducible]
def result.SeqIter.Insts.CoreIterTraitsIteratorIterator (A : Type) :
  iter.traits.iterator.Iterator (result.SeqIter A) A := {
  next := result.SeqIter.Insts.CoreIterTraitsIteratorIterator.next
}

/-- [core_models::result::{impl core_models::ops::try_trait::Try<T, core_models::result::Result<core_models::convert::Infallible, E>> for core_models::result::Result<T, E>}::branch]:
    Source: 'core-models/src/core/result.rs', lines 420:4-425:5
    Visibility: public -/
def result.Result.Insts.CoreOpsTry_traitTryTResultInfallibleE.branch
  {T : Type} {E : Type} (self : result.Result T E) :
  RustM (ops.control_flow.ControlFlow (result.Result convert.Infallible E) T)
  := do
  match self with
  | core.result.Result.Ok v => Aeneas.Std.RustM.ok (ops.control_flow.ControlFlow.Continue v)
  | core.result.Result.Err e =>
    Aeneas.Std.RustM.ok (ops.control_flow.ControlFlow.Break (result.Result.Err e))

/-- [core_models::result::{impl core_models::ops::try_trait::Try<T, core_models::result::Result<core_models::convert::Infallible, E>> for core_models::result::Result<T, E>}::from_output]:
    Source: 'core-models/src/core/result.rs', lines 415:4-417:5
    Visibility: public -/
def
  result.Result.Insts.CoreOpsTry_traitTryTResultInfallibleE.from_output
  {T : Type} (E : Type) (output : T) : RustM (result.Result T E) := do
  Aeneas.Std.RustM.ok (result.Result.Ok output)

/-- Trait implementation: [core_models::result::{impl core_models::ops::try_trait::Try<T, core_models::result::Result<core_models::convert::Infallible, E>> for core_models::result::Result<T, E>}]
    Source: 'core-models/src/core/result.rs', lines 410:0-426:1 -/
@[reducible]
def result.Result.Insts.CoreOpsTry_traitTryTResultInfallibleE (T : Type)
  (E : Type) : ops.try_trait.Try (result.Result T E) T (result.Result
  convert.Infallible E) := {
  from_output :=
    result.Result.Insts.CoreOpsTry_traitTryTResultInfallibleE.from_output
    E
  branch :=
    result.Result.Insts.CoreOpsTry_traitTryTResultInfallibleE.branch
}

/-- [core_models::result::{core_models::result::Result<core_models::option::Option<T>, E>}::transpose]:
    Source: 'core-models/src/core/result.rs', lines 432:4-438:5
    Visibility: public -/
def result.ResultOptionE.transpose
  {T : Type} {E : Type} (self : result.Result (option.Option T) E) :
  RustM (option.Option (result.Result T E))
  := do
  match self with
  | core.result.Result.Ok o =>
    match o with
    | option.Option.Some t => Aeneas.Std.RustM.ok (option.Option.Some (result.Result.Ok t))
    | option.Option.None => Aeneas.Std.RustM.ok option.Option.None
  | core.result.Result.Err e => Aeneas.Std.RustM.ok (option.Option.Some (result.Result.Err e))

/-- [core_models::result::{impl core_models::cmp::PartialEq<core_models::result::Result<T, E>> for core_models::result::Result<T, E>}::eq]:
    Source: 'core-models/src/core/result.rs', lines 448:4-454:5
    Visibility: public -/
def result.Result.Insts.CoreCmpPartialEqResult.eq
  {T : Type} {E : Type} (cmpPartialEqInst : cmp.PartialEq T T)
  (cmpPartialEqInst1 : cmp.PartialEq E E) (self : result.Result T E)
  (other : result.Result T E) :
  RustM Bool
  := do
  match self with
  | core.result.Result.Ok a =>
    match other with
    | core.result.Result.Ok b => cmpPartialEqInst.eq a b
    | core.result.Result.Err _ => Aeneas.Std.RustM.ok false
  | core.result.Result.Err a =>
    match other with
    | core.result.Result.Ok _ => Aeneas.Std.RustM.ok false
    | core.result.Result.Err b => cmpPartialEqInst1.eq a b

/-- Trait implementation: [core_models::result::{impl core_models::cmp::PartialEq<core_models::result::Result<T, E>> for core_models::result::Result<T, E>}]
    Source: 'core-models/src/core/result.rs', lines 445:0-455:1 -/
@[reducible]
impl_def result.Result.Insts.CoreCmpPartialEqResult {T : Type} {E :
  Type} (cmpPartialEqInst : cmp.PartialEq T T) (cmpPartialEqInst1 :
  cmp.PartialEq E E) : cmp.PartialEq (result.Result T E) (result.Result T E)
  := {
  eq := result.Result.Insts.CoreCmpPartialEqResult.eq cmpPartialEqInst
    cmpPartialEqInst1
  ne := cmp.PartialEq.ne.default
    (result.Result.Insts.CoreCmpPartialEqResult cmpPartialEqInst
    cmpPartialEqInst1)
}

/-- [core_models::result::{impl core_models::ops::try_trait::FromResidual<core_models::result::Result<core_models::convert::Infallible, E>> for core_models::result::Result<T, F>}::from_residual]:
    Source: 'core-models/src/core/result.rs', lines 465:4-470:5
    Visibility: public -/
def
  result.Result.Insts.CoreOpsTry_traitFromResidualResultInfallibleE.from_residual
  (T : Type) {E : Type} {F : Type} (convertFromInst : convert.From F E)
  (residual : result.Result convert.Infallible E) :
  RustM (result.Result T F)
  := do
  match residual with
  | core.result.Result.Ok _ => panicking.internal.panic (result.Result T F)
  | core.result.Result.Err e =>
    let t ← convertFromInst.«from» e
    Aeneas.Std.RustM.ok (result.Result.Err t)

/-- Trait implementation: [core_models::result::{impl core_models::ops::try_trait::FromResidual<core_models::result::Result<core_models::convert::Infallible, E>> for core_models::result::Result<T, F>}]
    Source: 'core-models/src/core/result.rs', lines 462:0-471:1 -/
@[reducible]
def result.Result.Insts.CoreOpsTry_traitFromResidualResultInfallibleE (T
  : Type) {E : Type} {F : Type} (convertFromInst : convert.From F E) :
  ops.try_trait.FromResidual (result.Result T F) (result.Result
  convert.Infallible E) := {
  from_residual :=
    result.Result.Insts.CoreOpsTry_traitFromResidualResultInfallibleE.from_residual
    T convertFromInst
}

/-- [core_models::slice::iter::{core_models::slice::iter::Chunks<'a, T>}::new]:
    Source: 'core-models/src/core/slice.rs', lines 19:8-21:9
    Visibility: public -/
def slice.iter.Chunks.new
  {T : Type} (cs : Std.Usize) (elements : Slice T) :
  RustM (slice.iter.Chunks T)
  := do
  ok { cs, elements }

/-- [core_models::slice::iter::{core_models::slice::iter::ChunksExact<'a, T>}::new]:
    Source: 'core-models/src/core/slice.rs', lines 29:8-31:9
    Visibility: public -/
def slice.iter.ChunksExact.new
  {T : Type} (cs : Std.Usize) (elements : Slice T) :
  RustM (slice.iter.ChunksExact T)
  := do
  ok { cs, elements }

/-- [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a T> for core_models::slice::iter::Iter<'a, T>}::next]:
    Source: 'core-models/src/core/slice.rs', lines 47:8-54:9
    Visibility: public -/
def slice.iter.Iter.Insts.CoreIterTraitsIteratorIteratorSharedAT.next
  {T : Type} (self : slice.iter.Iter T) :
  RustM ((option.Option T) × (slice.iter.Iter T))
  := do
  let i ← rust_primitives.sequence.seq_len self
  if i = 0#usize
  then ok (option.Option.None, self)
  else
    let (res, s) ← rust_primitives.sequence.seq_remove self 0#usize
    ok (option.Option.Some res, s)

/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a T> for core_models::slice::iter::Iter<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 45:4-55:5 -/
@[reducible]
def slice.iter.Iter.Insts.CoreIterTraitsIteratorIteratorSharedAT (T :
  Type) : iter.traits.iterator.Iterator (slice.iter.Iter T) T := {
  next :=
    slice.iter.Iter.Insts.CoreIterTraitsIteratorIteratorSharedAT.next
}

/-- [core_models::slice::iter::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<&'_ T> for core_models::slice::iter::Iter<'a, T>}::next_back]:
    Source: 'core-models/src/core/slice.rs', lines 62:8-70:9
    Visibility: public -/
def
  slice.iter.Iter.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorSharedT.next_back
  {T : Type} (self : slice.iter.Iter T) :
  RustM ((option.Option T) × (slice.iter.Iter T))
  := do
  let n ← rust_primitives.sequence.seq_len self
  if n = 0#usize
  then ok (option.Option.None, self)
  else
    let i ← n - 1#usize
    let (res, s) ← rust_primitives.sequence.seq_remove self i
    ok (option.Option.Some res, s)

/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::double_ended::DoubleEndedIterator<&'_ T> for core_models::slice::iter::Iter<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 61:4-71:5 -/
@[reducible]
def
  slice.iter.Iter.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorSharedT
  (T : Type) : iter.traits.double_ended.DoubleEndedIterator (slice.iter.Iter T)
  T := {
  iteratorIteratorInst :=
    slice.iter.Iter.Insts.CoreIterTraitsIteratorIteratorSharedAT T
  next_back :=
    slice.iter.Iter.Insts.CoreIterTraitsDouble_endedDoubleEndedIteratorSharedT.next_back
}

/-- [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a mut T> for core_models::slice::iter::IterMut<'a, T>}::next]:
    Source: 'core-models/src/core/slice.rs', lines 76:8-83:9
    Visibility: public -/
def slice.iter.IterMut.Insts.CoreIterTraitsIteratorIteratorMutAT.next
  {T : Type} (self : slice.iter.IterMut T) :
  RustM ((option.Option T) × (slice.iter.IterMut T) × (slice.iter.IterMut T
    → option.Option T → slice.iter.IterMut T))
  := do
  let i ← rust_primitives.sequence.seq_len self
  if i = 0#usize
  then let back'a := fun self1 o => self1
       ok (option.Option.None, self, back'a)
  else
    let (res, s, seq_remove_mut_back) ←
      rust_primitives.sequence.seq_remove_mut self 0#usize
    let back'a :=
      fun self1 o =>
        let t := match o with
                 | option.Option.Some t1 => t1
                 | _ => res
        let s1 := seq_remove_mut_back self1 t
        s1
    ok (option.Option.Some res, s, back'a)

/-
/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a mut T> for core_models::slice::iter::IterMut<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 74:4-84:5 -/
@[reducible]
def slice.iter.IterMut.Insts.CoreIterTraitsIteratorIteratorMutAT (T :
  Type) : iter.traits.iterator.Iterator (slice.iter.IterMut T) T := {
  next :=
    slice.iter.IterMut.Insts.CoreIterTraitsIteratorIteratorMutAT.next
}
-/  -- IterMut::next has a write-back return, which no Iterator instance can hold (Aeneas has no such instance either)

/-- [core_models::slice::iter::{impl core_models::iter::traits::exact_size::ExactSizeIterator<&'_ T> for core_models::slice::iter::Iter<'a, T>}::len]:
    Source: 'core-models/src/core/slice.rs', lines 88:8-90:9
    Visibility: public -/
def
  slice.iter.Iter.Insts.CoreIterTraitsExact_sizeExactSizeIteratorSharedT.len
  {T : Type} (self : slice.iter.Iter T) : RustM Std.Usize := do
  rust_primitives.sequence.seq_len self

/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::exact_size::ExactSizeIterator<&'_ T> for core_models::slice::iter::Iter<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 87:4-91:5 -/
@[reducible]
def
  slice.iter.Iter.Insts.CoreIterTraitsExact_sizeExactSizeIteratorSharedT
  (T : Type) : iter.traits.exact_size.ExactSizeIterator (slice.iter.Iter T) T
  := {
  iteratorIteratorInst :=
    slice.iter.Iter.Insts.CoreIterTraitsIteratorIteratorSharedAT T
  len :=
    slice.iter.Iter.Insts.CoreIterTraitsExact_sizeExactSizeIteratorSharedT.len
}

/-- [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a [T]> for core_models::slice::iter::Chunks<'a, T>}::next]:
    Source: 'core-models/src/core/slice.rs', lines 95:8-107:9
    Visibility: public -/
def
  slice.iter.Chunks.Insts.CoreIterTraitsIteratorIteratorSharedASlice.next
  {T : Type} (self : slice.iter.Chunks T) :
  RustM ((option.Option (Slice T)) × (slice.iter.Chunks T))
  := do
  let i ← rust_primitives.slice.slice_length self.elements
  if i = 0#usize
  then ok (option.Option.None, self)
  else
    if i < self.cs
    then
      let s ← rust_primitives.slice.slice_slice self.elements 0#usize 0#usize
      ok (option.Option.Some self.elements, { self with elements := s })
    else
      let (res, new_elements) ←
        rust_primitives.slice.slice_split_at self.elements self.cs
      ok (option.Option.Some res, { self with elements := new_elements })

/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a [T]> for core_models::slice::iter::Chunks<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 93:4-108:5 -/
@[reducible]
def slice.iter.Chunks.Insts.CoreIterTraitsIteratorIteratorSharedASlice
  (T : Type) : iter.traits.iterator.Iterator (slice.iter.Chunks T) (Slice T)
  := {
  next :=
    slice.iter.Chunks.Insts.CoreIterTraitsIteratorIteratorSharedASlice.next
}

/-- [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a [T]> for core_models::slice::iter::ChunksExact<'a, T>}::next]:
    Source: 'core-models/src/core/slice.rs', lines 112:8-120:9
    Visibility: public -/
def
  slice.iter.ChunksExact.Insts.CoreIterTraitsIteratorIteratorSharedASlice.next
  {T : Type} (self : slice.iter.ChunksExact T) :
  RustM ((option.Option (Slice T)) × (slice.iter.ChunksExact T))
  := do
  let i ← rust_primitives.slice.slice_length self.elements
  if i < self.cs
  then ok (option.Option.None, self)
  else
    let (res, new_elements) ←
      rust_primitives.slice.slice_split_at self.elements self.cs
    ok (option.Option.Some res, { self with elements := new_elements })

/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a [T]> for core_models::slice::iter::ChunksExact<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 110:4-121:5 -/
@[reducible]
def
  slice.iter.ChunksExact.Insts.CoreIterTraitsIteratorIteratorSharedASlice
  (T : Type) : iter.traits.iterator.Iterator (slice.iter.ChunksExact T) (Slice
  T) := {
  next :=
    slice.iter.ChunksExact.Insts.CoreIterTraitsIteratorIteratorSharedASlice.next
}

/-- [core_models::slice::iter::{core_models::slice::iter::Windows<'a, T>}::new]:
    Source: 'core-models/src/core/slice.rs', lines 129:8-131:9
    Visibility: public -/
def slice.iter.Windows.new
  {T : Type} (size : Std.Usize) (elements : Slice T) :
  RustM (slice.iter.Windows T)
  := do
  ok { size, elements }

/-- [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a [T]> for core_models::slice::iter::Windows<'a, T>}::next]:
    Source: 'core-models/src/core/slice.rs', lines 138:8-146:9
    Visibility: public -/
def
  slice.iter.Windows.Insts.CoreIterTraitsIteratorIteratorSharedASlice.next
  {T : Type} (self : slice.iter.Windows T) :
  RustM ((option.Option (Slice T)) × (slice.iter.Windows T))
  := do
  let i ← rust_primitives.slice.slice_length self.elements
  if i < self.size
  then ok (option.Option.None, self)
  else
    let res ←
      rust_primitives.slice.slice_slice self.elements 0#usize self.size
    let s ← rust_primitives.slice.slice_slice self.elements 1#usize i
    ok (option.Option.Some res, { self with elements := s })

/-- Trait implementation: [core_models::slice::iter::{impl core_models::iter::traits::iterator::Iterator<&'a [T]> for core_models::slice::iter::Windows<'a, T>}]
    Source: 'core-models/src/core/slice.rs', lines 136:4-147:5 -/
@[reducible]
def slice.iter.Windows.Insts.CoreIterTraitsIteratorIteratorSharedASlice
  (T : Type) : iter.traits.iterator.Iterator (slice.iter.Windows T) (Slice T)
  := {
  next :=
    slice.iter.Windows.Insts.CoreIterTraitsIteratorIteratorSharedASlice.next
}

/-- [core_models::slice::{core_models::slice::Slice<T>}::len]:
    Source: 'core-models/src/core/slice.rs', lines 153:4-155:5 -/
def slice.Slice.len {T : Type} (s : Slice T) : RustM Std.Usize := do
  rust_primitives.slice.slice_length s

/-- [core_models::slice::{core_models::slice::Slice<T>}::chunks]:
    Source: 'core-models/src/core/slice.rs', lines 158:4-163:5 -/
def slice.Slice.chunks
  {T : Type} (s : Slice T) (cs : Std.Usize) : RustM (slice.iter.Chunks T) := do
  if cs = 0#usize
  then panicking.internal.panic Unit
  else ok ()
  slice.iter.Chunks.new cs s

/-- [core_models::slice::{core_models::slice::Slice<T>}::iter]:
    Source: 'core-models/src/core/slice.rs', lines 165:4-167:5 -/
def slice.Slice.iter {T : Type} (s : Slice T) : RustM (slice.iter.Iter T) := do
  let s1 ← rust_primitives.sequence.seq_from_slice s
  ok s1

/-- [core_models::slice::{core_models::slice::Slice<T>}::chunks_exact]:
    Source: 'core-models/src/core/slice.rs', lines 170:4-175:5 -/
def slice.Slice.chunks_exact
  {T : Type} (s : Slice T) (cs : Std.Usize) :
  RustM (slice.iter.ChunksExact T)
  := do
  if cs = 0#usize
  then panicking.internal.panic Unit
  else ok ()
  slice.iter.ChunksExact.new cs s

/-- [core_models::slice::{core_models::slice::Slice<T>}::copy_from_slice]:
    Source: 'core-models/src/core/slice.rs', lines 178:4-183:5 -/
def slice.Slice.copy_from_slice
  {T : Type} (coremarkerCopyInst : core.marker.Copy T) (s : Slice T)
  (src : Slice T) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_clone_from_slice
    coremarkerCopyInst.cloneCloneInst s src

/-- [core_models::slice::{core_models::slice::Slice<T>}::clone_from_slice]:
    Source: 'core-models/src/core/slice.rs', lines 186:4-191:5 -/
def slice.Slice.clone_from_slice
  {T : Type} (corecloneCloneInst : core.clone.Clone T) (s : Slice T)
  (src : Slice T) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_clone_from_slice corecloneCloneInst s src

/-- [core_models::slice::{core_models::slice::Slice<T>}::split_at]:
    Source: 'core-models/src/core/slice.rs', lines 194:4-196:5 -/
def slice.Slice.split_at
  {T : Type} (s : Slice T) (mid : Std.Usize) :
  RustM ((Slice T) × (Slice T))
  := do
  rust_primitives.slice.slice_split_at s mid

/-- [core_models::slice::{core_models::slice::Slice<T>}::split_at_mut]:
    Source: 'core-models/src/core/slice.rs', lines 201:4-203:5 -/
def slice.Slice.split_at_mut
  {T : Type} (s : Slice T) (mid : Std.Usize) :
  RustM (((Slice T) × (Slice T)) × (((Slice T) × (Slice T)) → Slice T))
  := do
  let ((s1, s2), slice_split_at_mut_back) ←
    rust_primitives.slice.slice_split_at_mut s mid
  let back := fun p => slice_split_at_mut_back p
  ok ((s1, s2), back)

/-- [core_models::slice::{core_models::slice::Slice<T>}::iter_mut]:
    Source: 'core-models/src/core/slice.rs', lines 207:4-209:5 -/
def slice.Slice.iter_mut
  {T : Type} (s : Slice T) :
  RustM ((slice.iter.IterMut T) × (slice.iter.IterMut T → Slice T))
  := do
  let (s1, seq_from_slice_mut_back) ←
    rust_primitives.sequence.seq_from_slice_mut s
  ok (s1, seq_from_slice_mut_back)

/-- [core_models::slice::{core_models::slice::Slice<T>}::split_at_checked]:
    Source: 'core-models/src/core/slice.rs', lines 211:4-217:5 -/
def slice.Slice.split_at_checked
  {T : Type} (s : Slice T) (mid : Std.Usize) :
  RustM (option.Option ((Slice T) × (Slice T)))
  := do
  let i ← slice.Slice.len s
  if mid <= i
  then
    let (s1, s2) ← slice.Slice.split_at s mid
    ok (option.Option.Some (s1, s2))
  else ok option.Option.None

/-- [core_models::slice::{core_models::slice::Slice<T>}::is_empty]:
    Source: 'core-models/src/core/slice.rs', lines 219:4-221:5 -/
def slice.Slice.is_empty {T : Type} (s : Slice T) : RustM Bool := do
  let i ← slice.Slice.len s
  ok (i = 0#usize)

/-- [core_models::slice::{core_models::slice::Slice<T>}::contains]:
    Source: 'core-models/src/core/slice.rs', lines 224:4-229:5 -/
def slice.Slice.contains
  {T : Type} (corecmpPartialEqInst : core.cmp.PartialEq T T) (s : Slice T)
  (v : T) :
  RustM Bool
  := do
  rust_primitives.slice.slice_contains corecmpPartialEqInst s v

/-- [core_models::slice::{core_models::slice::Slice<T>}::binary_search]: loop body 0:
    Source: 'core-models/src/core/slice.rs', lines 254:8-263:5 -/
@[rust_loop_body]
def slice.Slice.binary_search_loop.body
  {T : Type} (cmpOrdInst : cmp.Ord T) (s : Slice T) (x : T) (low : Std.Usize)
  (high : Std.Usize) :
  RustM (ControlFlow (Std.Usize × Std.Usize) (result.Result Std.Usize
    Std.Usize))
  := do
  if low < high
  then
    let i ← high - low
    let i1 ← i / 2#usize
    let mid ← low + i1
    let t ← rust_primitives.slice.slice_index s mid
    let o ← cmpOrdInst.cmp t x
    match o with
    | cmp.Ordering.Less => let low1 ← mid + 1#usize
                           ok (cont (low1, high))
    | cmp.Ordering.Equal => ok (done (result.Result.Ok mid))
    | cmp.Ordering.Greater => ok (cont (low, mid))
  else ok (done (result.Result.Err low))

/-- [core_models::slice::{core_models::slice::Slice<T>}::binary_search]: loop 0:
    Source: 'core-models/src/core/slice.rs', lines 254:8-263:5 -/
@[rust_loop]
def slice.Slice.binary_search_loop
  {T : Type} (cmpOrdInst : cmp.Ord T) (s : Slice T) (x : T) (low : Std.Usize)
  (high : Std.Usize) :
  RustM (result.Result Std.Usize Std.Usize)
  := do
  loop
    (fun (low1, high1) => slice.Slice.binary_search_loop.body cmpOrdInst s x
      low1 high1)
    (low, high)

/-- [core_models::slice::{core_models::slice::Slice<T>}::binary_search]:
    Source: 'core-models/src/core/slice.rs', lines 248:4-263:5 -/
def slice.Slice.binary_search
  {T : Type} (cmpOrdInst : cmp.Ord T) (s : Slice T) (x : T) :
  RustM (result.Result Std.Usize Std.Usize)
  := do
  let high ← slice.Slice.len s
  slice.Slice.binary_search_loop cmpOrdInst s x 0#usize high

/-- [core_models::slice::{core_models::slice::Slice<T>}::get]:
    Source: 'core-models/src/core/slice.rs', lines 265:4-267:5 -/
def slice.Slice.get
  {T : Type} {I : Type} {Clause0_Output : Type}
  (indexSliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice T)
  Clause0_Output) (s : Slice T) (index : I) :
  RustM (option.Option Clause0_Output)
  := do
  indexSliceIndexISliceClause0_OutputInst.get index s

/-- [core_models::slice::{core_models::slice::Slice<T>}::get_unchecked]:
    Source: 'core-models/src/core/slice.rs', lines 273:4-275:5 -/
def slice.Slice.get_unchecked
  {T : Type} {I : Type} {Clause0_Output : Type}
  (indexSliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice T)
  Clause0_Output) (s : Slice T) (index : I) :
  RustM Clause0_Output
  := do
  indexSliceIndexISliceClause0_OutputInst.get_unchecked index s

/-- [core_models::slice::{core_models::slice::Slice<T>}::get_mut]:
    Source: 'core-models/src/core/slice.rs', lines 279:4-284:5 -/
def slice.Slice.get_mut
  {T : Type} {I : Type} {Clause0_Output : Type}
  (indexSliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice T)
  Clause0_Output) (s : Slice T) (index : I) :
  RustM ((option.Option Clause0_Output) × (option.Option Clause0_Output →
    Slice T))
  := do
  indexSliceIndexISliceClause0_OutputInst.get_mut index s

/-- [core_models::slice::{core_models::slice::Slice<T>}::get_unchecked_mut]:
    Source: 'core-models/src/core/slice.rs', lines 288:4-293:5 -/
def slice.Slice.get_unchecked_mut
  {T : Type} {I : Type} {Clause0_Output : Type}
  (indexSliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice T)
  Clause0_Output) (s : Slice T) (index : I) :
  RustM (Clause0_Output × (Clause0_Output → Slice T))
  := do
  indexSliceIndexISliceClause0_OutputInst.get_unchecked_mut index s

/-- [core_models::slice::{core_models::slice::Slice<T>}::first]:
    Source: 'core-models/src/core/slice.rs', lines 295:4-301:5 -/
def slice.Slice.first {T : Type} (s : Slice T) : RustM (option.Option T) := do
  let b ← slice.Slice.is_empty s
  if b
  then ok option.Option.None
  else
    let t ← rust_primitives.slice.slice_index s 0#usize
    ok (option.Option.Some t)

/-- [core_models::slice::{core_models::slice::Slice<T>}::last]:
    Source: 'core-models/src/core/slice.rs', lines 303:4-309:5 -/
def slice.Slice.last {T : Type} (s : Slice T) : RustM (option.Option T) := do
  let b ← slice.Slice.is_empty s
  if b
  then ok option.Option.None
  else
    let i ← slice.Slice.len s
    let i1 ← i - 1#usize
    let t ← rust_primitives.slice.slice_index s i1
    ok (option.Option.Some t)

/-- [core_models::slice::{core_models::slice::Slice<T>}::swap]:
    Source: 'core-models/src/core/slice.rs', lines 314:4-316:5 -/
def slice.Slice.swap
  {T : Type} (s : Slice T) (a : Std.Usize) (b : Std.Usize) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_swap s a b

/-- [core_models::slice::{core_models::slice::Slice<T>}::reverse]:
    Source: 'core-models/src/core/slice.rs', lines 320:4-322:5 -/
def slice.Slice.reverse {T : Type} (s : Slice T) : RustM (Slice T) := do
  rust_primitives.slice.slice_reverse s

/-- [core_models::slice::{core_models::slice::Slice<T>}::windows]:
    Source: 'core-models/src/core/slice.rs', lines 325:4-330:5 -/
def slice.Slice.windows
  {T : Type} (s : Slice T) (size : Std.Usize) :
  RustM (slice.iter.Windows T)
  := do
  if size = 0#usize
  then panicking.internal.panic Unit
  else ok ()
  slice.iter.Windows.new size s

/-- [core_models::slice::{core_models::slice::Slice<T>}::fill]: loop body 0:
    Source: 'core-models/src/core/slice.rs', lines 338:8-340:9 -/
@[rust_loop_body]
def slice.Slice.fill_loop.body
  {T : Type} (corecloneCloneInst : core.clone.Clone T) (value : T)
  (iter1 : core.ops.range.Range Std.Usize) (s : Slice T) :
  RustM (ControlFlow ((core.ops.range.Range Std.Usize) × (Slice T)) (Slice T))
  := do
  let (o, iter2) ←
    core.ops.range.Range.Insts.CoreIterTraitsIteratorIterator.next
      core.Usize.Insts.CoreIterRangeStep iter1
  match o with
  | core.option.Option.None => ok (done s)
  | core.option.Option.Some i =>
    let t ← corecloneCloneInst.clone value
    let (t1, index_mut_back) ← Slice.index_mut_usize s i
    let s1 := index_mut_back t1
    let s2 ← Slice.update s1 i t
    ok (cont (iter2, s2))

/-- [core_models::slice::{core_models::slice::Slice<T>}::fill]: loop 0:
    Source: 'core-models/src/core/slice.rs', lines 338:8-340:9 -/
@[rust_loop]
def slice.Slice.fill_loop
  {T : Type} (corecloneCloneInst : core.clone.Clone T)
  (iter1 : core.ops.range.Range Std.Usize) (s : Slice T) (value : T) :
  RustM (Slice T)
  := do
  loop
    (fun (iter2, s1) => slice.Slice.fill_loop.body corecloneCloneInst value
      iter2 s1)
    (iter1, s)

/-- [core_models::slice::{core_models::slice::Slice<T>}::fill]:
    Source: 'core-models/src/core/slice.rs', lines 334:4-341:5 -/
def slice.Slice.fill
  {T : Type} (corecloneCloneInst : core.clone.Clone T) (s : Slice T)
  (value : T) :
  RustM (Slice T)
  := do
  let i ← core.slice.Slice.len s
  slice.Slice.fill_loop corecloneCloneInst { start := 0#usize, «end» := i } s
    value

/-- [core_models::slice::{impl core_models::cmp::PartialEq<[U]> for [T]}::eq]: loop body 0:
    Source: 'core-models/src/core/slice.rs', lines 383:12-388:13
    Visibility: public -/
@[rust_loop_body]
def Slice.Insts.CoreCmpPartialEqSlice.eq_loop.body
  {U : Type} {T : Type} (cmpPartialEqInst : cmp.PartialEq T U) (self : Slice T)
  (other : Slice U) (iter1 : core.ops.range.Range Std.Usize) (res : Bool) :
  RustM (ControlFlow ((core.ops.range.Range Std.Usize) × Bool) Bool)
  := do
  let (o, iter2) ←
    core.ops.range.Range.Insts.CoreIterTraitsIteratorIterator.next
      core.Usize.Insts.CoreIterRangeStep iter1
  match o with
  | core.option.Option.None => ok (done res)
  | core.option.Option.Some i =>
    if res
    then
      let t ← Slice.index_usize self i
      let t1 ← Slice.index_usize other i
      let b ← cmpPartialEqInst.eq t t1
      if b
      then ok (cont (iter2, true))
      else ok (cont (iter2, false))
    else ok (cont (iter2, false))

/-- [core_models::slice::{impl core_models::cmp::PartialEq<[U]> for [T]}::eq]: loop 0:
    Source: 'core-models/src/core/slice.rs', lines 383:12-388:13
    Visibility: public -/
@[rust_loop]
def Slice.Insts.CoreCmpPartialEqSlice.eq_loop
  {U : Type} {T : Type} (cmpPartialEqInst : cmp.PartialEq T U)
  (iter1 : core.ops.range.Range Std.Usize) (self : Slice T) (other : Slice U)
  (res : Bool) :
  RustM Bool
  := do
  loop
    (fun (iter2, res1) => Slice.Insts.CoreCmpPartialEqSlice.eq_loop.body
      cmpPartialEqInst self other iter2 res1)
    (iter1, res)

/-- [core_models::slice::{impl core_models::cmp::PartialEq<[U]> for [T]}::eq]:
    Source: 'core-models/src/core/slice.rs', lines 378:4-391:5
    Visibility: public -/
def Slice.Insts.CoreCmpPartialEqSlice.eq
  {U : Type} {T : Type} (cmpPartialEqInst : cmp.PartialEq T U) (self : Slice T)
  (other : Slice U) :
  RustM Bool
  := do
  let i ← core.slice.Slice.len self
  let i1 ← core.slice.Slice.len other
  if i != i1
  then ok false
  else
    Slice.Insts.CoreCmpPartialEqSlice.eq_loop cmpPartialEqInst
      { start := 0#usize, «end» := i } self other true

/-- [core_models::slice::{impl core_models::cmp::PartialEq<[U]> for [T]}::ne]:
    Source: 'core-models/src/core/slice.rs', lines 375:4-377:5
    Visibility: public -/
def Slice.Insts.CoreCmpPartialEqSlice.ne
  {U : Type} {T : Type} (cmpPartialEqInst : cmp.PartialEq T U) (self : Slice T)
  (other : Slice U) :
  RustM Bool
  := do
  let b ←
    Slice.Insts.CoreCmpPartialEqSlice.eq cmpPartialEqInst self other
  ok (b = false)

/-- Trait implementation: [core_models::slice::{impl core_models::cmp::PartialEq<[U]> for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 373:0-392:1 -/
@[reducible]
def Slice.Insts.CoreCmpPartialEqSlice {U : Type} {T : Type}
  (cmpPartialEqInst : cmp.PartialEq T U) : cmp.PartialEq (Slice T) (Slice U)
  := {
  eq := Slice.Insts.CoreCmpPartialEqSlice.eq cmpPartialEqInst
  ne := Slice.Insts.CoreCmpPartialEqSlice.ne cmpPartialEqInst
}

/-- Trait implementation: [core_models::slice::{impl core_models::cmp::Eq for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 395:0-395:49 -/
@[reducible]
def Slice.Insts.CoreCmpEq {T : Type} (cmpEqInst : cmp.Eq T) : cmp.Eq
  (Slice T) := {
  PartialEqInst := Slice.Insts.CoreCmpPartialEqSlice
    cmpEqInst.PartialEqInst
}

/-- [core_models::slice::{impl core_models::cmp::PartialOrd<[T]> for [T]}::partial_cmp]: loop body 0:
    Source: 'core-models/src/core/slice.rs', lines 408:8-422:5
    Visibility: public -/
@[rust_loop_body]
def Slice.Insts.CoreCmpPartialOrdSlice.partial_cmp_loop.body
  {T : Type} (cmpPartialOrdInst : cmp.PartialOrd T T) (self : Slice T)
  (other : Slice T) (iter1 : core.ops.range.Range Std.Usize) :
  RustM (ControlFlow (core.ops.range.Range Std.Usize) (option.Option
    cmp.Ordering))
  := do
  let (o, iter2) ←
    core.ops.range.Range.Insts.CoreIterTraitsIteratorIterator.next
      core.Usize.Insts.CoreIterRangeStep iter1
  match o with
  | core.option.Option.None =>
    let i ← core.slice.Slice.len self
    let i1 ← core.slice.Slice.len other
    if i < i1
    then ok (done (option.Option.Some cmp.Ordering.Less))
    else
      if i > i1
      then ok (done (option.Option.Some cmp.Ordering.Greater))
      else ok (done (option.Option.Some cmp.Ordering.Equal))
  | core.option.Option.Some i =>
    let t ← Slice.index_usize self i
    let t1 ← Slice.index_usize other i
    let o1 ← cmpPartialOrdInst.partial_cmp t t1
    match o1 with
    | option.Option.Some o2 =>
      match o2 with
      | cmp.Ordering.Less => ok (done o1)
      | cmp.Ordering.Equal => ok (cont iter2)
      | cmp.Ordering.Greater => ok (done o1)
    | option.Option.None => ok (done option.Option.None)

/-- [core_models::slice::{impl core_models::cmp::PartialOrd<[T]> for [T]}::partial_cmp]: loop 0:
    Source: 'core-models/src/core/slice.rs', lines 408:8-422:5
    Visibility: public -/
@[rust_loop]
def Slice.Insts.CoreCmpPartialOrdSlice.partial_cmp_loop
  {T : Type} (cmpPartialOrdInst : cmp.PartialOrd T T)
  (iter1 : core.ops.range.Range Std.Usize) (self : Slice T) (other : Slice T) :
  RustM (option.Option cmp.Ordering)
  := do
  loop
    (fun iter2 =>
      Slice.Insts.CoreCmpPartialOrdSlice.partial_cmp_loop.body
      cmpPartialOrdInst self other iter2)
    iter1

/-- [core_models::slice::{impl core_models::cmp::PartialOrd<[T]> for [T]}::partial_cmp]:
    Source: 'core-models/src/core/slice.rs', lines 400:4-422:5
    Visibility: public -/
def Slice.Insts.CoreCmpPartialOrdSlice.partial_cmp
  {T : Type} (cmpPartialOrdInst : cmp.PartialOrd T T) (self : Slice T)
  (other : Slice T) :
  RustM (option.Option cmp.Ordering)
  := do
  let i ← core.slice.Slice.len self
  let i1 ← core.slice.Slice.len other
  let l ← if i < i1
            then ok i
            else ok i1
  Slice.Insts.CoreCmpPartialOrdSlice.partial_cmp_loop cmpPartialOrdInst
    { start := 0#usize, «end» := l } self other

/-- Trait implementation: [core_models::slice::{impl core_models::cmp::PartialOrd<[T]> for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 399:0-423:1 -/
@[reducible]
impl_def Slice.Insts.CoreCmpPartialOrdSlice {T : Type}
  (cmpPartialOrdInst : cmp.PartialOrd T T) : cmp.PartialOrd (Slice T) (Slice T)
  := {
  PartialEqInst := Slice.Insts.CoreCmpPartialEqSlice
    cmpPartialOrdInst.PartialEqInst
  partial_cmp := Slice.Insts.CoreCmpPartialOrdSlice.partial_cmp
    cmpPartialOrdInst
  lt := cmp.PartialOrd.lt.default (Slice.Insts.CoreCmpPartialOrdSlice
    cmpPartialOrdInst)
  le := cmp.PartialOrd.le.default (Slice.Insts.CoreCmpPartialOrdSlice
    cmpPartialOrdInst)
  gt := cmp.PartialOrd.gt.default (Slice.Insts.CoreCmpPartialOrdSlice
    cmpPartialOrdInst)
  ge := cmp.PartialOrd.ge.default (Slice.Insts.CoreCmpPartialOrdSlice
    cmpPartialOrdInst)
}

/-- [core_models::slice::{impl core_models::cmp::Ord for [T]}::cmp]: loop body 0:
    Source: 'core-models/src/core/slice.rs', lines 436:8-450:5
    Visibility: public -/
@[rust_loop_body]
def Slice.Insts.CoreCmpOrd.cmp_loop.body
  {T : Type} (cmpOrdInst : cmp.Ord T) (self : Slice T) (other : Slice T)
  (iter1 : core.ops.range.Range Std.Usize) :
  RustM (ControlFlow (core.ops.range.Range Std.Usize) cmp.Ordering)
  := do
  let (o, iter2) ←
    core.ops.range.Range.Insts.CoreIterTraitsIteratorIterator.next
      core.Usize.Insts.CoreIterRangeStep iter1
  match o with
  | core.option.Option.None =>
    let i ← core.slice.Slice.len self
    let i1 ← core.slice.Slice.len other
    if i < i1
    then ok (done cmp.Ordering.Less)
    else
      if i > i1
      then ok (done cmp.Ordering.Greater)
      else ok (done cmp.Ordering.Equal)
  | core.option.Option.Some i =>
    let t ← Slice.index_usize self i
    let t1 ← Slice.index_usize other i
    let o1 ← cmpOrdInst.cmp t t1
    match o1 with
    | cmp.Ordering.Less => ok (done cmp.Ordering.Less)
    | cmp.Ordering.Equal => ok (cont iter2)
    | cmp.Ordering.Greater => ok (done cmp.Ordering.Greater)

/-- [core_models::slice::{impl core_models::cmp::Ord for [T]}::cmp]: loop 0:
    Source: 'core-models/src/core/slice.rs', lines 436:8-450:5
    Visibility: public -/
@[rust_loop]
def Slice.Insts.CoreCmpOrd.cmp_loop
  {T : Type} (cmpOrdInst : cmp.Ord T) (iter1 : core.ops.range.Range Std.Usize)
  (self : Slice T) (other : Slice T) :
  RustM cmp.Ordering
  := do
  loop
    (fun iter2 => Slice.Insts.CoreCmpOrd.cmp_loop.body cmpOrdInst self
      other iter2)
    iter1

/-- [core_models::slice::{impl core_models::cmp::Ord for [T]}::cmp]:
    Source: 'core-models/src/core/slice.rs', lines 428:4-450:5
    Visibility: public -/
def Slice.Insts.CoreCmpOrd.cmp
  {T : Type} (cmpOrdInst : cmp.Ord T) (self : Slice T) (other : Slice T) :
  RustM cmp.Ordering
  := do
  let i ← core.slice.Slice.len self
  let i1 ← core.slice.Slice.len other
  let l ← if i < i1
            then ok i
            else ok i1
  Slice.Insts.CoreCmpOrd.cmp_loop cmpOrdInst
    { start := 0#usize, «end» := l } self other

/-- Trait implementation: [core_models::slice::{impl core_models::cmp::Ord for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 427:0-451:1 -/
@[reducible]
def Slice.Insts.CoreCmpOrd {T : Type} (cmpOrdInst : cmp.Ord T) : cmp.Ord
  (Slice T) := {
  EqInst := Slice.Insts.CoreCmpEq cmpOrdInst.EqInst
  PartialOrdInst := Slice.Insts.CoreCmpPartialOrdSlice
    cmpOrdInst.PartialOrdInst
  cmp := Slice.Insts.CoreCmpOrd.cmp cmpOrdInst
}

/-- [core_models::slice::{core_models::slice::Slice<T>}::starts_with]:
    Source: 'core-models/src/core/slice.rs', lines 462:4-468:5 -/
def slice.Slice.starts_with
  {T : Type} (corecmpPartialEqInst : core.cmp.PartialEq T T) (s : Slice T)
  (needle : Slice T) :
  RustM Bool
  := do
  let n ← slice.Slice.len needle
  let i ← slice.Slice.len s
  if i >= n
  then
    let s1 ← rust_primitives.slice.slice_slice s 0#usize n
    core.Slice.Insts.CoreCmpPartialEqSlice.eq corecmpPartialEqInst s1 needle
  else ok false

/-- [core_models::slice::{core_models::slice::Slice<T>}::ends_with]:
    Source: 'core-models/src/core/slice.rs', lines 472:4-479:5 -/
def slice.Slice.ends_with
  {T : Type} (corecmpPartialEqInst : core.cmp.PartialEq T T) (s : Slice T)
  (needle : Slice T) :
  RustM Bool
  := do
  let n ← slice.Slice.len needle
  let l ← slice.Slice.len s
  if l >= n
  then
    let i ← l - n
    let s1 ← rust_primitives.slice.slice_slice s i l
    core.Slice.Insts.CoreCmpPartialEqSlice.eq corecmpPartialEqInst s1 needle
  else ok false

/-- [core_models::slice::{impl core_models::iter::traits::collect::IntoIterator<&'a T, core_models::slice::iter::Iter<'a, T>> for &'a [T]}::into_iter]:
    Source: 'core-models/src/core/slice.rs', lines 487:4-489:5
    Visibility: public -/
def
  SharedASlice.Insts.CoreIterTraitsCollectIntoIteratorSharedATIter.into_iter
  {T : Type} (self : Slice T) : RustM (slice.iter.Iter T) := do
  let i ← slice.Slice.iter self
  ok i

/-- Trait implementation: [core_models::slice::{impl core_models::iter::traits::collect::IntoIterator<&'a T, core_models::slice::iter::Iter<'a, T>> for &'a [T]}]
    Source: 'core-models/src/core/slice.rs', lines 484:0-490:1 -/
@[reducible]
def SharedASlice.Insts.CoreIterTraitsCollectIntoIteratorSharedATIter (T
  : Type) : iter.traits.collect.IntoIterator (Slice T) T (slice.iter.Iter T)
  := {
  iteratorIteratorInst :=
    slice.iter.Iter.Insts.CoreIterTraitsIteratorIteratorSharedAT T
  into_iter :=
    SharedASlice.Insts.CoreIterTraitsCollectIntoIteratorSharedATIter.into_iter
}

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}::index_mut]:
    Source: 'core-models/src/core/slice.rs', lines 567:8-569:9
    Visibility: public -/
def Usize.Insts.CoreSliceIndexSliceIndexSliceT.index_mut
  {T : Type} (self : Std.Usize) (slice1 : Slice T) :
  RustM (T × (T → Slice T))
  := do
  rust_primitives.slice.slice_index_mut slice1 self

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}::get_unchecked_mut]:
    Source: 'core-models/src/core/slice.rs', lines 562:8-564:9
    Visibility: public -/
def Usize.Insts.CoreSliceIndexSliceIndexSliceT.get_unchecked_mut
  {T : Type} (self : Std.Usize) (slice1 : Slice T) :
  RustM (T × (T → Slice T))
  := do
  rust_primitives.slice.slice_index_mut slice1 self

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}::get_mut]:
    Source: 'core-models/src/core/slice.rs', lines 553:8-559:9
    Visibility: public -/
def Usize.Insts.CoreSliceIndexSliceIndexSliceT.get_mut
  {T : Type} (self : Std.Usize) (slice1 : Slice T) :
  RustM ((option.Option T) × (option.Option T → Slice T))
  := do
  let i ← rust_primitives.slice.slice_length slice1
  if self < i
  then
    let (t, slice_index_mut_back) ←
      rust_primitives.slice.slice_index_mut slice1 self
    let back :=
      fun o =>
        let t1 := match o with
                  | option.Option.Some t2 => t2
                  | _ => t
        slice_index_mut_back t1
    ok (option.Option.Some t, back)
  else let back := fun o => slice1
       ok (option.Option.None, back)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}::get_unchecked]:
    Source: 'core-models/src/core/slice.rs', lines 549:8-551:9
    Visibility: public -/
def Usize.Insts.CoreSliceIndexSliceIndexSliceT.get_unchecked
  {T : Type} (self : Std.Usize) (slice1 : Slice T) : RustM T := do
  rust_primitives.slice.slice_index slice1 self

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}::index]:
    Source: 'core-models/src/core/slice.rs', lines 545:8-547:9
    Visibility: public -/
def Usize.Insts.CoreSliceIndexSliceIndexSliceT.index
  {T : Type} (self : Std.Usize) (slice1 : Slice T) : RustM T := do
  rust_primitives.slice.slice_index slice1 self

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}::get]:
    Source: 'core-models/src/core/slice.rs', lines 537:8-543:9
    Visibility: public -/
def Usize.Insts.CoreSliceIndexSliceIndexSliceT.get
  {T : Type} (self : Std.Usize) (slice1 : Slice T) :
  RustM (option.Option T)
  := do
  let i ← rust_primitives.slice.slice_length slice1
  if self < i
  then
    let t ← rust_primitives.slice.slice_index slice1 self
    ok (option.Option.Some t)
  else ok option.Option.None

/-- Trait implementation: [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], T> for usize}]
    Source: 'core-models/src/core/slice.rs', lines 535:4-570:5 -/
@[reducible]
def Usize.Insts.CoreSliceIndexSliceIndexSliceT (T : Type) :
  slice.index.SliceIndex Std.Usize (Slice T) T := {
  get := Usize.Insts.CoreSliceIndexSliceIndexSliceT.get
  index := Usize.Insts.CoreSliceIndexSliceIndexSliceT.index
  get_unchecked :=
    Usize.Insts.CoreSliceIndexSliceIndexSliceT.get_unchecked
  get_mut := Usize.Insts.CoreSliceIndexSliceIndexSliceT.get_mut
  get_unchecked_mut :=
    Usize.Insts.CoreSliceIndexSliceIndexSliceT.get_unchecked_mut
  index_mut := Usize.Insts.CoreSliceIndexSliceIndexSliceT.index_mut
}

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}::index_mut]:
    Source: 'core-models/src/core/slice.rs', lines 594:8-596:9
    Visibility: public -/
def
  ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
  {T : Type} (self : ops.range.RangeFull) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  ok (slice1, fun slice2 => slice2)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}::get_unchecked_mut]:
    Source: 'core-models/src/core/slice.rs', lines 590:8-592:9
    Visibility: public -/
def
  ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  {T : Type} (self : ops.range.RangeFull) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  ok (slice1, fun slice2 => slice2)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}::get_mut]:
    Source: 'core-models/src/core/slice.rs', lines 586:8-588:9
    Visibility: public -/
def ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  {T : Type} (self : ops.range.RangeFull) (slice1 : Slice T) :
  RustM ((option.Option (Slice T)) × (option.Option (Slice T) → Slice T))
  := do
  let back := fun o => match o with
                       | option.Option.Some s => s
                       | _ => slice1
  ok (option.Option.Some slice1, back)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}::get_unchecked]:
    Source: 'core-models/src/core/slice.rs', lines 582:8-584:9
    Visibility: public -/
def
  ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  {T : Type} (self : ops.range.RangeFull) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  ok slice1

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}::index]:
    Source: 'core-models/src/core/slice.rs', lines 579:8-581:9
    Visibility: public -/
def ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  {T : Type} (self : ops.range.RangeFull) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  ok slice1

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}::get]:
    Source: 'core-models/src/core/slice.rs', lines 576:8-578:9
    Visibility: public -/
def ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  {T : Type} (self : ops.range.RangeFull) (slice1 : Slice T) :
  RustM (option.Option (Slice T))
  := do
  ok (option.Option.Some slice1)

/-- Trait implementation: [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFull}]
    Source: 'core-models/src/core/slice.rs', lines 574:4-597:5 -/
@[reducible]
def ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice (T :
  Type) : slice.index.SliceIndex ops.range.RangeFull (Slice T) (Slice T) := {
  get :=
    ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  index :=
    ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  get_unchecked :=
    ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  get_mut :=
    ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  get_unchecked_mut :=
    ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  index_mut :=
    ops.range.RangeFull.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
}

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}::index_mut]:
    Source: 'core-models/src/core/slice.rs', lines 635:8-638:9
    Visibility: public -/
def
  ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
  {T : Type} (self : ops.range.RangeFrom Std.Usize) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  let len ← rust_primitives.slice.slice_length slice1
  rust_primitives.slice.slice_slice_mut slice1 self.start len

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}::get_unchecked_mut]:
    Source: 'core-models/src/core/slice.rs', lines 629:8-632:9
    Visibility: public -/
def
  ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  {T : Type} (self : ops.range.RangeFrom Std.Usize) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  let len ← rust_primitives.slice.slice_length slice1
  rust_primitives.slice.slice_slice_mut slice1 self.start len

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}::get_mut]:
    Source: 'core-models/src/core/slice.rs', lines 619:8-626:9
    Visibility: public -/
def
  ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  {T : Type} (self : ops.range.RangeFrom Std.Usize) (slice1 : Slice T) :
  RustM ((option.Option (Slice T)) × (option.Option (Slice T) → Slice T))
  := do
  let len ← rust_primitives.slice.slice_length slice1
  if self.start <= len
  then
    let (s, slice_slice_mut_back) ←
      rust_primitives.slice.slice_slice_mut slice1 self.start len
    let back :=
      fun o =>
        let s1 := match o with
                  | option.Option.Some s2 => s2
                  | _ => s
        slice_slice_mut_back s1
    ok (option.Option.Some s, back)
  else let back := fun o => slice1
       ok (option.Option.None, back)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}::get_unchecked]:
    Source: 'core-models/src/core/slice.rs', lines 615:8-617:9
    Visibility: public -/
def
  ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  {T : Type} (self : ops.range.RangeFrom Std.Usize) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  let i ← rust_primitives.slice.slice_length slice1
  rust_primitives.slice.slice_slice slice1 self.start i

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}::index]:
    Source: 'core-models/src/core/slice.rs', lines 611:8-613:9
    Visibility: public -/
def
  ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  {T : Type} (self : ops.range.RangeFrom Std.Usize) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  let i ← rust_primitives.slice.slice_length slice1
  rust_primitives.slice.slice_slice slice1 self.start i

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}::get]:
    Source: 'core-models/src/core/slice.rs', lines 603:8-609:9
    Visibility: public -/
def
  ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  {T : Type} (self : ops.range.RangeFrom Std.Usize) (slice1 : Slice T) :
  RustM (option.Option (Slice T))
  := do
  let i ← rust_primitives.slice.slice_length slice1
  if self.start <= i
  then
    let s ← rust_primitives.slice.slice_slice slice1 self.start i
    ok (option.Option.Some s)
  else ok option.Option.None

/-- Trait implementation: [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeFrom<usize>}]
    Source: 'core-models/src/core/slice.rs', lines 601:4-639:5 -/
@[reducible]
def ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice (T
  : Type) : slice.index.SliceIndex (ops.range.RangeFrom Std.Usize) (Slice T)
  (Slice T) := {
  get :=
    ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  index :=
    ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  get_unchecked :=
    ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  get_mut :=
    ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  get_unchecked_mut :=
    ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  index_mut :=
    ops.range.RangeFromUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
}

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}::index_mut]:
    Source: 'core-models/src/core/slice.rs', lines 674:8-676:9
    Visibility: public -/
def
  ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
  {T : Type} (self : ops.range.RangeTo Std.Usize) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  rust_primitives.slice.slice_slice_mut slice1 0#usize self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}::get_unchecked_mut]:
    Source: 'core-models/src/core/slice.rs', lines 669:8-671:9
    Visibility: public -/
def
  ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  {T : Type} (self : ops.range.RangeTo Std.Usize) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  rust_primitives.slice.slice_slice_mut slice1 0#usize self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}::get_mut]:
    Source: 'core-models/src/core/slice.rs', lines 660:8-666:9
    Visibility: public -/
def
  ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  {T : Type} (self : ops.range.RangeTo Std.Usize) (slice1 : Slice T) :
  RustM ((option.Option (Slice T)) × (option.Option (Slice T) → Slice T))
  := do
  let i ← rust_primitives.slice.slice_length slice1
  if self.end <= i
  then
    let (s, slice_slice_mut_back) ←
      rust_primitives.slice.slice_slice_mut slice1 0#usize self.end
    let back :=
      fun o =>
        let s1 := match o with
                  | option.Option.Some s2 => s2
                  | _ => s
        slice_slice_mut_back s1
    ok (option.Option.Some s, back)
  else let back := fun o => slice1
       ok (option.Option.None, back)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}::get_unchecked]:
    Source: 'core-models/src/core/slice.rs', lines 656:8-658:9
    Visibility: public -/
def
  ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  {T : Type} (self : ops.range.RangeTo Std.Usize) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_slice slice1 0#usize self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}::index]:
    Source: 'core-models/src/core/slice.rs', lines 652:8-654:9
    Visibility: public -/
def
  ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  {T : Type} (self : ops.range.RangeTo Std.Usize) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_slice slice1 0#usize self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}::get]:
    Source: 'core-models/src/core/slice.rs', lines 644:8-650:9
    Visibility: public -/
def ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  {T : Type} (self : ops.range.RangeTo Std.Usize) (slice1 : Slice T) :
  RustM (option.Option (Slice T))
  := do
  let i ← rust_primitives.slice.slice_length slice1
  if self.end <= i
  then
    let s ← rust_primitives.slice.slice_slice slice1 0#usize self.end
    ok (option.Option.Some s)
  else ok option.Option.None

/-- Trait implementation: [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::RangeTo<usize>}]
    Source: 'core-models/src/core/slice.rs', lines 642:4-677:5 -/
@[reducible]
def ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice (T :
  Type) : slice.index.SliceIndex (ops.range.RangeTo Std.Usize) (Slice T) (Slice
  T) := {
  get :=
    ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  index :=
    ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  get_unchecked :=
    ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  get_mut :=
    ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  get_unchecked_mut :=
    ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  index_mut :=
    ops.range.RangeToUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
}

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}::index_mut]:
    Source: 'core-models/src/core/slice.rs', lines 712:8-714:9
    Visibility: public -/
def
  ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
  {T : Type} (self : ops.range.Range Std.Usize) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  rust_primitives.slice.slice_slice_mut slice1 self.start self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}::get_unchecked_mut]:
    Source: 'core-models/src/core/slice.rs', lines 707:8-709:9
    Visibility: public -/
def
  ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  {T : Type} (self : ops.range.Range Std.Usize) (slice1 : Slice T) :
  RustM ((Slice T) × (Slice T → Slice T))
  := do
  rust_primitives.slice.slice_slice_mut slice1 self.start self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}::get_mut]:
    Source: 'core-models/src/core/slice.rs', lines 698:8-704:9
    Visibility: public -/
def
  ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  {T : Type} (self : ops.range.Range Std.Usize) (slice1 : Slice T) :
  RustM ((option.Option (Slice T)) × (option.Option (Slice T) → Slice T))
  := do
  if self.start <= self.end
  then
    let i ← rust_primitives.slice.slice_length slice1
    if self.end <= i
    then
      let (s, slice_slice_mut_back) ←
        rust_primitives.slice.slice_slice_mut slice1 self.start self.end
      let back :=
        fun o =>
          let s1 := match o with
                    | option.Option.Some s2 => s2
                    | _ => s
          slice_slice_mut_back s1
      ok (option.Option.Some s, back)
    else let back := fun o => slice1
         ok (option.Option.None, back)
  else let back := fun o => slice1
       ok (option.Option.None, back)

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}::get_unchecked]:
    Source: 'core-models/src/core/slice.rs', lines 694:8-696:9
    Visibility: public -/
def
  ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  {T : Type} (self : ops.range.Range Std.Usize) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_slice slice1 self.start self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}::index]:
    Source: 'core-models/src/core/slice.rs', lines 690:8-692:9
    Visibility: public -/
def ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  {T : Type} (self : ops.range.Range Std.Usize) (slice1 : Slice T) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_slice slice1 self.start self.end

/-- [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}::get]:
    Source: 'core-models/src/core/slice.rs', lines 682:8-688:9
    Visibility: public -/
def ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  {T : Type} (self : ops.range.Range Std.Usize) (slice1 : Slice T) :
  RustM (option.Option (Slice T))
  := do
  if self.start <= self.end
  then
    let i ← rust_primitives.slice.slice_length slice1
    if self.end <= i
    then
      let s ← rust_primitives.slice.slice_slice slice1 self.start self.end
      ok (option.Option.Some s)
    else ok option.Option.None
  else ok option.Option.None

/-- Trait implementation: [core_models::slice::index::{impl core_models::slice::index::SliceIndex<[T], [T]> for core_models::ops::range::Range<usize>}]
    Source: 'core-models/src/core/slice.rs', lines 680:4-715:5 -/
@[reducible]
def ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice (T :
  Type) : slice.index.SliceIndex (ops.range.Range Std.Usize) (Slice T) (Slice
  T) := {
  get :=
    ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get
  index :=
    ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index
  get_unchecked :=
    ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked
  get_mut :=
    ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_mut
  get_unchecked_mut :=
    ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.get_unchecked_mut
  index_mut :=
    ops.range.RangeUsize.Insts.CoreSliceIndexSliceIndexSliceSlice.index_mut
}

/-- [core_models::slice::index::{impl core_models::ops::index::Index<I, Clause0_Output> for [T]}::index]:
    Source: 'core-models/src/core/slice.rs', lines 731:8-736:9
    Visibility: public -/
def Slice.Insts.CoreOpsIndexIndex.index
  {T : Type} {I : Type} {Clause0_Output : Type}
  (SliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice T)
  Clause0_Output) (self : Slice T) (i : I) :
  RustM Clause0_Output
  := do
  let o ← SliceIndexISliceClause0_OutputInst.get i self
  match o with
  | option.Option.Some r => ok r
  | option.Option.None => panicking.internal.panic Clause0_Output

/-- Trait implementation: [core_models::slice::index::{impl core_models::ops::index::Index<I, Clause0_Output> for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 725:4-737:5 -/
@[reducible]
def Slice.Insts.CoreOpsIndexIndex {T : Type} {I : Type} {Clause0_Output
  : Type} (SliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice
  T) Clause0_Output) : ops.index.Index (Slice T) I Clause0_Output := {
  index := Slice.Insts.CoreOpsIndexIndex.index
    SliceIndexISliceClause0_OutputInst
}

/-- [core_models::slice::index::{impl core_models::ops::index::IndexMut<I, Clause0_Output> for [T]}::index_mut]:
    Source: 'core-models/src/core/slice.rs', lines 756:8-758:9
    Visibility: public -/
def Slice.Insts.CoreOpsIndexIndexMut.index_mut
  {T : Type} {I : Type} {Clause0_Output : Type}
  (SliceIndexISliceClause0_OutputInst : slice.index.SliceIndex I (Slice T)
  Clause0_Output) (self : Slice T) (i : I) :
  RustM (Clause0_Output × (Clause0_Output → Slice T))
  := do
  SliceIndexISliceClause0_OutputInst.get_unchecked_mut i self

/-- Trait implementation: [core_models::slice::index::{impl core_models::ops::index::IndexMut<I, Clause0_Output> for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 745:4-759:5 -/
@[reducible]
def Slice.Insts.CoreOpsIndexIndexMut {T : Type} {I : Type}
  {Clause0_Output : Type} (SliceIndexISliceClause0_OutputInst :
  slice.index.SliceIndex I (Slice T) Clause0_Output) : ops.index.IndexMut
  (Slice T) I Clause0_Output := {
  IndexInst := Slice.Insts.CoreOpsIndexIndex
    SliceIndexISliceClause0_OutputInst
  index_mut := Slice.Insts.CoreOpsIndexIndexMut.index_mut
    SliceIndexISliceClause0_OutputInst
}

/-- [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::Range<usize>, [T]> for &'_0 [T]}::index]:
    Source: 'core-models/src/core/slice.rs', lines 774:4-776:5
    Visibility: public -/
def Shared0Slice.Insts.CoreOpsIndexIndexRangeUsizeSlice.index
  {T : Type} (self : Slice T) (i : ops.range.Range Std.Usize) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_slice self i.start i.end

/-- Trait implementation: [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::Range<usize>, [T]> for &'_0 [T]}]
    Source: 'core-models/src/core/slice.rs', lines 771:0-777:1 -/
@[reducible]
def Shared0Slice.Insts.CoreOpsIndexIndexRangeUsizeSlice (T : Type) :
  ops.index.Index (Slice T) (ops.range.Range Std.Usize) (Slice T) := {
  index := Shared0Slice.Insts.CoreOpsIndexIndexRangeUsizeSlice.index
}

/-- [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::RangeTo<usize>, [T]> for &'_0 [T]}::index]:
    Source: 'core-models/src/core/slice.rs', lines 783:4-785:5
    Visibility: public -/
def Shared0Slice.Insts.CoreOpsIndexIndexRangeToUsizeSlice.index
  {T : Type} (self : Slice T) (i : ops.range.RangeTo Std.Usize) :
  RustM (Slice T)
  := do
  rust_primitives.slice.slice_slice self 0#usize i.end

/-- Trait implementation: [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::RangeTo<usize>, [T]> for &'_0 [T]}]
    Source: 'core-models/src/core/slice.rs', lines 780:0-786:1 -/
@[reducible]
def Shared0Slice.Insts.CoreOpsIndexIndexRangeToUsizeSlice (T : Type) :
  ops.index.Index (Slice T) (ops.range.RangeTo Std.Usize) (Slice T) := {
  index := Shared0Slice.Insts.CoreOpsIndexIndexRangeToUsizeSlice.index
}

/-- [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::RangeFrom<usize>, [T]> for &'_0 [T]}::index]:
    Source: 'core-models/src/core/slice.rs', lines 792:4-794:5
    Visibility: public -/
def Shared0Slice.Insts.CoreOpsIndexIndexRangeFromUsizeSlice.index
  {T : Type} (self : Slice T) (i : ops.range.RangeFrom Std.Usize) :
  RustM (Slice T)
  := do
  let i1 ← rust_primitives.slice.slice_length self
  rust_primitives.slice.slice_slice self i.start i1

/-- Trait implementation: [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::RangeFrom<usize>, [T]> for &'_0 [T]}]
    Source: 'core-models/src/core/slice.rs', lines 789:0-795:1 -/
@[reducible]
def Shared0Slice.Insts.CoreOpsIndexIndexRangeFromUsizeSlice (T : Type) :
  ops.index.Index (Slice T) (ops.range.RangeFrom Std.Usize) (Slice T) := {
  index := Shared0Slice.Insts.CoreOpsIndexIndexRangeFromUsizeSlice.index
}

/-- [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::RangeFull, [T]> for &'_0 [T]}::index]:
    Source: 'core-models/src/core/slice.rs', lines 800:4-802:5
    Visibility: public -/
def Shared0Slice.Insts.CoreOpsIndexIndexRangeFullSlice.index
  {T : Type} (self : Slice T) (i : ops.range.RangeFull) : RustM (Slice T) := do
  let i1 ← rust_primitives.slice.slice_length self
  rust_primitives.slice.slice_slice self 0#usize i1

/-- Trait implementation: [core_models::slice::{impl core_models::ops::index::Index<core_models::ops::range::RangeFull, [T]> for &'_0 [T]}]
    Source: 'core-models/src/core/slice.rs', lines 798:0-803:1 -/
@[reducible]
def Shared0Slice.Insts.CoreOpsIndexIndexRangeFullSlice (T : Type) :
  ops.index.Index (Slice T) ops.range.RangeFull (Slice T) := {
  index := Shared0Slice.Insts.CoreOpsIndexIndexRangeFullSlice.index
}

/-- [core_models::slice::{impl core_models::ops::index::Index<usize, T> for &'_0 [T]}::index]:
    Source: 'core-models/src/core/slice.rs', lines 810:4-812:5
    Visibility: public -/
def Shared0Slice.Insts.CoreOpsIndexIndexUsizeT.index
  {T : Type} (self : Slice T) (i : Std.Usize) : RustM T := do
  rust_primitives.slice.slice_index self i

/-- Trait implementation: [core_models::slice::{impl core_models::ops::index::Index<usize, T> for &'_0 [T]}]
    Source: 'core-models/src/core/slice.rs', lines 807:0-813:1 -/
@[reducible]
def Shared0Slice.Insts.CoreOpsIndexIndexUsizeT (T : Type) :
  ops.index.Index (Slice T) Std.Usize T := {
  index := Shared0Slice.Insts.CoreOpsIndexIndexUsizeT.index
}

/-- [core_models::slice::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T]}::eq]: loop body 0:
    Source: 'core-models/src/core/slice.rs', lines 832:16-837:17
    Visibility: public -/
@[rust_loop_body]
def Slice.Insts.CoreCmpPartialEqArray.eq_loop.body
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Slice T) (other : Array U N) (iter1 : core.ops.range.Range Std.Usize)
  (res : Bool) :
  RustM (ControlFlow ((core.ops.range.Range Std.Usize) × Bool) Bool)
  := do
  let (o, iter2) ←
    core.ops.range.Range.Insts.CoreIterTraitsIteratorIterator.next
      core.Usize.Insts.CoreIterRangeStep iter1
  match o with
  | core.option.Option.None => ok (done res)
  | core.option.Option.Some i =>
    if res
    then
      let t ← rust_primitives.slice.slice_index self i
      let t1 ← rust_primitives.slice.array_index other i
      let b ← cmpPartialEqInst.eq t t1
      if b
      then ok (cont (iter2, true))
      else ok (cont (iter2, false))
    else ok (cont (iter2, false))

/-- [core_models::slice::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T]}::eq]: loop 0:
    Source: 'core-models/src/core/slice.rs', lines 832:16-837:17
    Visibility: public -/
@[rust_loop]
def Slice.Insts.CoreCmpPartialEqArray.eq_loop
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (iter1 : core.ops.range.Range Std.Usize) (self : Slice T) (other : Array U N)
  (res : Bool) :
  RustM Bool
  := do
  loop
    (fun (iter2, res1) => Slice.Insts.CoreCmpPartialEqArray.eq_loop.body
      cmpPartialEqInst self other iter2 res1)
    (iter1, res)

/-- [core_models::slice::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T]}::eq]:
    Source: 'core-models/src/core/slice.rs', lines 827:8-840:9
    Visibility: public -/
def Slice.Insts.CoreCmpPartialEqArray.eq
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Slice T) (other : Array U N) :
  RustM Bool
  := do
  let i ← rust_primitives.slice.slice_length self
  if i != N
  then ok false
  else
    Slice.Insts.CoreCmpPartialEqArray.eq_loop cmpPartialEqInst
      { start := 0#usize, «end» := N } self other true

/-- [core_models::slice::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T]}::ne]:
    Source: 'core-models/src/core/slice.rs', lines 824:8-826:9
    Visibility: public -/
def Slice.Insts.CoreCmpPartialEqArray.ne
  {T : Type} {U : Type} {N : Std.Usize} (cmpPartialEqInst : cmp.PartialEq T U)
  (self : Slice T) (other : Array U N) :
  RustM Bool
  := do
  let b ←
    Slice.Insts.CoreCmpPartialEqArray.eq cmpPartialEqInst self other
  ok (b = false)

/-- Trait implementation: [core_models::slice::equality::{impl core_models::cmp::PartialEq<[U; N]> for [T]}]
    Source: 'core-models/src/core/slice.rs', lines 822:4-841:5 -/
@[reducible]
def Slice.Insts.CoreCmpPartialEqArray {T : Type} {U : Type} (N :
  Std.Usize) (cmpPartialEqInst : cmp.PartialEq T U) : cmp.PartialEq (Slice T)
  (Array U N) := {
  eq := Slice.Insts.CoreCmpPartialEqArray.eq cmpPartialEqInst
  ne := Slice.Insts.CoreCmpPartialEqArray.ne cmpPartialEqInst
}

/-- [core_models::str::traits::{impl core_models::str::traits::FromStr<u64> for u64}::from_str]:
    Source: 'core-models/src/core/str.rs', lines 70:8-72:9 -/
def U64.Insts.CoreStrTraitsFromStrU64.from_str
  (s : Str) : RustM (result.Result Std.U64 Std.U64) := do
  fail Error.panic

/-- Trait implementation: [core_models::str::traits::{impl core_models::str::traits::FromStr<u64> for u64}]
    Source: 'core-models/src/core/str.rs', lines 64:4-73:5 -/
@[reducible]
def U64.Insts.CoreStrTraitsFromStrU64 : str.traits.FromStr Std.U64
  Std.U64 := {
  from_str := U64.Insts.CoreStrTraitsFromStrU64.from_str
}


/-- [core_models::iter::adapters::step_by::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::step_by::StepBy<I>}::next]: loop body 0:
    Source: 'core-models/src/core/iter.rs', lines 607:16-609:17
    Visibility: public -/
@[rust_loop_body]
def
  iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator.next_loop.body
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (iter1 : core.ops.range.Range Std.Usize) (t : I) :
  RustM (ControlFlow ((core.ops.range.Range Std.Usize) × I) I)
  := do
  let (o, iter2) ←
    core.ops.range.Range.Insts.CoreIterTraitsIteratorIterator.next
      core.Usize.Insts.CoreIterRangeStep iter1
  match o with
  | core.option.Option.None => ok (done t)
  | core.option.Option.Some _ =>
    let (_, t1) ← traitsiteratorIteratorInst.next t
    ok (cont (iter2, t1))

/-- [core_models::iter::adapters::step_by::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::step_by::StepBy<I>}::next]: loop 0:
    Source: 'core-models/src/core/iter.rs', lines 607:16-609:17
    Visibility: public -/
@[rust_loop]
def
  iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator.next_loop
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (iter1 : core.ops.range.Range Std.Usize) (t : I) :
  RustM I
  := do
  loop
    (fun (iter2, t1) =>
      iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator.next_loop.body
      traitsiteratorIteratorInst iter2 t1)
    (iter1, t)

/-- [core_models::iter::adapters::step_by::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::step_by::StepBy<I>}::next]:
    Source: 'core-models/src/core/iter.rs', lines 603:12-611:13
    Visibility: public -/
def
  iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator.next
  {I : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item)
  (self : iter.adapters.step_by.StepBy I) :
  RustM ((option.Option Clause0_Item) × (iter.adapters.step_by.StepBy I))
  := do
  let (current, t) ← traitsiteratorIteratorInst.next self.iter
  let t1 ←
    iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator.next_loop
      traitsiteratorIteratorInst { start := 1#usize, «end» := self.step } t
  ok (current, { self with iter := t1 })

/-- Trait implementation: [core_models::iter::adapters::step_by::{impl core_models::iter::traits::iterator::Iterator<Clause0_Item> for core_models::iter::adapters::step_by::StepBy<I>}]
    Source: 'core-models/src/core/iter.rs', lines 599:8-612:9 -/
@[reducible]
def iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator {I
  : Type} {Clause0_Item : Type} (traitsiteratorIteratorInst :
  iter.traits.iterator.Iterator I Clause0_Item) : iter.traits.iterator.Iterator
  (iter.adapters.step_by.StepBy I) Clause0_Item := {
  next :=
    iter.adapters.step_by.StepBy.Insts.CoreIterTraitsIteratorIterator.next
    traitsiteratorIteratorInst
}

end CoreModels.core