(* Generated by coq-of-rust *)
Require Import CoqOfRust.CoqOfRust.

Module range.
  Module iter.
    (* StructTuple
      {
        name := "IterRange";
        const_params := [];
        ty_params := [ "A" ];
        fields := [ Ty.apply (Ty.path "core::ops::range::Range") [] [ A ] ];
      } *)
    
    Module Impl_core_fmt_Debug_where_core_fmt_Debug_A_for_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      (* Debug *)
      Definition fmt (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; f ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let f := M.alloc (| f |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::fmt::Formatter",
                "debug_tuple_field1_finish",
                []
              |),
              [
                M.read (| f |);
                M.read (| Value.String "IterRange" |);
                M.alloc (|
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "core::range::iter::IterRange",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::fmt::Debug"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method (fmt A)) ].
    End Impl_core_fmt_Debug_where_core_fmt_Debug_A_for_core_range_iter_IterRange_A.
    
    Module Impl_core_clone_Clone_where_core_clone_Clone_A_for_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      (* Clone *)
      Definition clone (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::range::iter::IterRange"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_tuple_field (|
                      M.read (| self |),
                      "core::range::iter::IterRange",
                      0
                    |)
                  ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::clone::Clone"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method (clone A)) ].
    End Impl_core_clone_Clone_where_core_clone_Clone_A_for_core_range_iter_IterRange_A.
    
    Module Impl_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      (*
          pub fn remainder(self) -> Range<A> {
              Range { start: self.0.start, end: self.0.end }
          }
      *)
      Definition remainder (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructRecord
              "core::range::Range"
              [
                ("start",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.SubPointer.get_struct_tuple_field (|
                        self,
                        "core::range::iter::IterRange",
                        0
                      |),
                      "core::ops::range::Range",
                      "start"
                    |)
                  |));
                ("end_",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.SubPointer.get_struct_tuple_field (|
                        self,
                        "core::range::iter::IterRange",
                        0
                      |),
                      "core::ops::range::Range",
                      "end"
                    |)
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_remainder :
        forall (A : Ty.t),
        M.IsAssociatedFunction (Self A) "remainder" (remainder A).
    End Impl_core_range_iter_IterRange_A.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_usize.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "usize" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_usize.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_usize.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "usize" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_usize.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u8" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u8.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u8" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u8.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u16.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u16" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u16.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u16.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u16" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u16.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_isize.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "isize" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_isize.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_isize.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "isize" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_isize.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i8" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i8.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i8" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i8.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i16.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i16" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i16.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i16.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i16" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i16.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u32.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u32" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u32.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u32.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u32" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u32.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i32.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i32" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i32.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i32.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i32" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i32.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u64.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u64" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_u64.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u64.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u64" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_u64.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i64.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i64" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccess"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_adapters_zip_TrustedRandomAccess_for_core_range_iter_IterRange_i64.
    
    Module Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i64.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i64" ].
      
      (*             const MAY_HAVE_SIDE_EFFECT: bool = false; *)
      (* Ty.path "bool" *)
      Definition value_MAY_HAVE_SIDE_EFFECT : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Bool false |))).
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::adapters::zip::TrustedRandomAccessNoCoerce"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("value_MAY_HAVE_SIDE_EFFECT", InstanceField.Constant value_MAY_HAVE_SIDE_EFFECT) ].
    End Impl_core_iter_adapters_zip_TrustedRandomAccessNoCoerce_for_core_range_iter_IterRange_i64.
    
    Module Impl_core_iter_traits_iterator_Iterator_where_core_iter_range_Step_A_for_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      (*     type Item = A; *)
      Definition _Item (A : Ty.t) : Ty.t := A.
      
      (*
          fn next(&mut self) -> Option<A> {
              self.0.next()
          }
      *)
      Definition next (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "next",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn size_hint(&self) -> (usize, Option<usize>) {
              self.0.size_hint()
          }
      *)
      Definition size_hint (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "size_hint",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn count(self) -> usize {
              self.0.count()
          }
      *)
      Definition count (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "count",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (| self, "core::range::iter::IterRange", 0 |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn nth(&mut self, n: usize) -> Option<A> {
              self.0.nth(n)
          }
      *)
      Definition nth (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "nth",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn last(self) -> Option<A> {
              self.0.last()
          }
      *)
      Definition last (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "last",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (| self, "core::range::iter::IterRange", 0 |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn min(self) -> Option<A>
          where
              A: Ord,
          {
              self.0.min()
          }
      *)
      Definition min (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "min",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (| self, "core::range::iter::IterRange", 0 |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn max(self) -> Option<A>
          where
              A: Ord,
          {
              self.0.max()
          }
      *)
      Definition max (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "max",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (| self, "core::range::iter::IterRange", 0 |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn is_sorted(self) -> bool {
              true
          }
      *)
      Definition is_sorted (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.Bool true))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
              self.0.advance_by(n)
          }
      *)
      Definition advance_by (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "advance_by",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
          where
              Self: TrustedRandomAccessNoCoerce,
          {
              // SAFETY: The TrustedRandomAccess contract requires that callers only pass an index
              // that is in bounds.
              // Additionally Self: TrustedRandomAccess is only implemented for Copy types
              // which means even repeated reads of the same index would be safe.
              unsafe { Step::forward_unchecked(self.0.start.clone(), idx) }
          }
      *)
      Definition __iterator_get_unchecked
          (A : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; idx ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let idx := M.alloc (| idx |) in
            M.call_closure (|
              M.get_trait_method (| "core::iter::range::Step", A, [], "forward_unchecked", [] |),
              [
                M.call_closure (|
                  M.get_trait_method (| "core::clone::Clone", A, [], "clone", [] |),
                  [
                    M.SubPointer.get_struct_record_field (|
                      M.SubPointer.get_struct_tuple_field (|
                        M.read (| self |),
                        "core::range::iter::IterRange",
                        0
                      |),
                      "core::ops::range::Range",
                      "start"
                    |)
                  ]
                |);
                M.read (| idx |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::iterator::Iterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("Item", InstanceField.Ty (_Item A));
            ("next", InstanceField.Method (next A));
            ("size_hint", InstanceField.Method (size_hint A));
            ("count", InstanceField.Method (count A));
            ("nth", InstanceField.Method (nth A));
            ("last", InstanceField.Method (last A));
            ("min", InstanceField.Method (min A));
            ("max", InstanceField.Method (max A));
            ("is_sorted", InstanceField.Method (is_sorted A));
            ("advance_by", InstanceField.Method (advance_by A));
            ("__iterator_get_unchecked", InstanceField.Method (__iterator_get_unchecked A))
          ].
    End Impl_core_iter_traits_iterator_Iterator_where_core_iter_range_Step_A_for_core_range_iter_IterRange_A.
    
    Module Impl_core_iter_traits_double_ended_DoubleEndedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      (*
          fn next_back(&mut self) -> Option<A> {
              self.0.next_back()
          }
      *)
      Definition next_back (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::double_ended::DoubleEndedIterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "next_back",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn nth_back(&mut self, n: usize) -> Option<A> {
              self.0.nth_back(n)
          }
      *)
      Definition nth_back (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::double_ended::DoubleEndedIterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "nth_back",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
              self.0.advance_back_by(n)
          }
      *)
      Definition advance_back_by
          (A : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::double_ended::DoubleEndedIterator",
                Ty.apply (Ty.path "core::ops::range::Range") [] [ A ],
                [],
                "advance_back_by",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRange",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::double_ended::DoubleEndedIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("next_back", InstanceField.Method (next_back A));
            ("nth_back", InstanceField.Method (nth_back A));
            ("advance_back_by", InstanceField.Method (advance_back_by A))
          ].
    End Impl_core_iter_traits_double_ended_DoubleEndedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRange_A.
    
    Module Impl_core_iter_traits_marker_TrustedLen_where_core_iter_traits_marker_TrustedStep_A_for_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::marker::TrustedLen"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_marker_TrustedLen_where_core_iter_traits_marker_TrustedStep_A_for_core_range_iter_IterRange_A.
    
    Module Impl_core_iter_traits_marker_FusedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRange_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::marker::FusedIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_marker_FusedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRange_A.
    
    Module Impl_core_iter_traits_collect_IntoIterator_where_core_iter_range_Step_A_for_core_range_Range_A.
      Definition Self (A : Ty.t) : Ty.t := Ty.apply (Ty.path "core::range::Range") [] [ A ].
      
      (*     type Item = A; *)
      Definition _Item (A : Ty.t) : Ty.t := A.
      
      (*     type IntoIter = IterRange<A>; *)
      Definition _IntoIter (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ A ].
      
      (*
          fn into_iter(self) -> Self::IntoIter {
              IterRange(self.into())
          }
      *)
      Definition into_iter (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::range::iter::IterRange"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::convert::Into",
                    Ty.apply (Ty.path "core::range::Range") [] [ A ],
                    [ Ty.apply (Ty.path "core::ops::range::Range") [] [ A ] ],
                    "into",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::collect::IntoIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("Item", InstanceField.Ty (_Item A));
            ("IntoIter", InstanceField.Ty (_IntoIter A));
            ("into_iter", InstanceField.Method (into_iter A))
          ].
    End Impl_core_iter_traits_collect_IntoIterator_where_core_iter_range_Step_A_for_core_range_Range_A.
    
    (* StructTuple
      {
        name := "IterRangeInclusive";
        const_params := [];
        ty_params := [ "A" ];
        fields := [ Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ] ];
      } *)
    
    Module Impl_core_fmt_Debug_where_core_fmt_Debug_A_for_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      (* Debug *)
      Definition fmt (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; f ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let f := M.alloc (| f |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::fmt::Formatter",
                "debug_tuple_field1_finish",
                []
              |),
              [
                M.read (| f |);
                M.read (| Value.String "IterRangeInclusive" |);
                M.alloc (|
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "core::range::iter::IterRangeInclusive",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::fmt::Debug"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method (fmt A)) ].
    End Impl_core_fmt_Debug_where_core_fmt_Debug_A_for_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_clone_Clone_where_core_clone_Clone_A_for_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      (* Clone *)
      Definition clone (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::range::iter::IterRangeInclusive"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_tuple_field (|
                      M.read (| self |),
                      "core::range::iter::IterRangeInclusive",
                      0
                    |)
                  ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::clone::Clone"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method (clone A)) ].
    End Impl_core_clone_Clone_where_core_clone_Clone_A_for_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      (*
          pub fn remainder(self) -> Option<RangeInclusive<A>> {
              if self.0.is_empty() {
                  return None;
              }
      
              Some(RangeInclusive { start: self.0.start, end: self.0.end })
          }
      *)
      Definition remainder (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply
                                        (Ty.path "core::ops::range::RangeInclusive")
                                        []
                                        [ A ],
                                      "is_empty",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_struct_tuple_field (|
                                        self,
                                        "core::range::iter::IterRangeInclusive",
                                        0
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (| Value.StructTuple "core::option::Option::None" [] |)
                                |)
                              |)
                            |)));
                        fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                      ]
                    |) in
                  M.alloc (|
                    Value.StructTuple
                      "core::option::Option::Some"
                      [
                        Value.StructRecord
                          "core::range::RangeInclusive"
                          [
                            ("start",
                              M.read (|
                                M.SubPointer.get_struct_record_field (|
                                  M.SubPointer.get_struct_tuple_field (|
                                    self,
                                    "core::range::iter::IterRangeInclusive",
                                    0
                                  |),
                                  "core::ops::range::RangeInclusive",
                                  "start"
                                |)
                              |));
                            ("end_",
                              M.read (|
                                M.SubPointer.get_struct_record_field (|
                                  M.SubPointer.get_struct_tuple_field (|
                                    self,
                                    "core::range::iter::IterRangeInclusive",
                                    0
                                  |),
                                  "core::ops::range::RangeInclusive",
                                  "end"
                                |)
                              |))
                          ]
                      ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_remainder :
        forall (A : Ty.t),
        M.IsAssociatedFunction (Self A) "remainder" (remainder A).
    End Impl_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_iter_traits_iterator_Iterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      (*     type Item = A; *)
      Definition _Item (A : Ty.t) : Ty.t := A.
      
      (*
          fn next(&mut self) -> Option<A> {
              self.0.next()
          }
      *)
      Definition next (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "next",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn size_hint(&self) -> (usize, Option<usize>) {
              self.0.size_hint()
          }
      *)
      Definition size_hint (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "size_hint",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn count(self) -> usize {
              self.0.count()
          }
      *)
      Definition count (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "count",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (|
                    self,
                    "core::range::iter::IterRangeInclusive",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn nth(&mut self, n: usize) -> Option<A> {
              self.0.nth(n)
          }
      *)
      Definition nth (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "nth",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn last(self) -> Option<A> {
              self.0.last()
          }
      *)
      Definition last (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "last",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (|
                    self,
                    "core::range::iter::IterRangeInclusive",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn min(self) -> Option<A>
          where
              A: Ord,
          {
              self.0.min()
          }
      *)
      Definition min (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "min",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (|
                    self,
                    "core::range::iter::IterRangeInclusive",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn max(self) -> Option<A>
          where
              A: Ord,
          {
              self.0.max()
          }
      *)
      Definition max (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "max",
                []
              |),
              [
                M.read (|
                  M.SubPointer.get_struct_tuple_field (|
                    self,
                    "core::range::iter::IterRangeInclusive",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn is_sorted(self) -> bool {
              true
          }
      *)
      Definition is_sorted (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.Bool true))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
              self.0.advance_by(n)
          }
      *)
      Definition advance_by (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "advance_by",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::iterator::Iterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("Item", InstanceField.Ty (_Item A));
            ("next", InstanceField.Method (next A));
            ("size_hint", InstanceField.Method (size_hint A));
            ("count", InstanceField.Method (count A));
            ("nth", InstanceField.Method (nth A));
            ("last", InstanceField.Method (last A));
            ("min", InstanceField.Method (min A));
            ("max", InstanceField.Method (max A));
            ("is_sorted", InstanceField.Method (is_sorted A));
            ("advance_by", InstanceField.Method (advance_by A))
          ].
    End Impl_core_iter_traits_iterator_Iterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_iter_traits_double_ended_DoubleEndedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      (*
          fn next_back(&mut self) -> Option<A> {
              self.0.next_back()
          }
      *)
      Definition next_back (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::double_ended::DoubleEndedIterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "next_back",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn nth_back(&mut self, n: usize) -> Option<A> {
              self.0.nth_back(n)
          }
      *)
      Definition nth_back (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::double_ended::DoubleEndedIterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "nth_back",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
              self.0.advance_back_by(n)
          }
      *)
      Definition advance_back_by
          (A : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::double_ended::DoubleEndedIterator",
                Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ],
                [],
                "advance_back_by",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeInclusive",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::double_ended::DoubleEndedIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("next_back", InstanceField.Method (next_back A));
            ("nth_back", InstanceField.Method (nth_back A));
            ("advance_back_by", InstanceField.Method (advance_back_by A))
          ].
    End Impl_core_iter_traits_double_ended_DoubleEndedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_iter_traits_marker_TrustedLen_where_core_iter_traits_marker_TrustedStep_A_for_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::marker::TrustedLen"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_marker_TrustedLen_where_core_iter_traits_marker_TrustedStep_A_for_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_iter_traits_marker_FusedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::marker::FusedIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_marker_FusedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeInclusive_A.
    
    Module Impl_core_iter_traits_collect_IntoIterator_where_core_iter_range_Step_A_for_core_range_RangeInclusive_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::RangeInclusive") [] [ A ].
      
      (*     type Item = A; *)
      Definition _Item (A : Ty.t) : Ty.t := A.
      
      (*     type IntoIter = IterRangeInclusive<A>; *)
      Definition _IntoIter (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ A ].
      
      (*
          fn into_iter(self) -> Self::IntoIter {
              IterRangeInclusive(self.into())
          }
      *)
      Definition into_iter (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::range::iter::IterRangeInclusive"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::convert::Into",
                    Ty.apply (Ty.path "core::range::RangeInclusive") [] [ A ],
                    [ Ty.apply (Ty.path "core::ops::range::RangeInclusive") [] [ A ] ],
                    "into",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::collect::IntoIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("Item", InstanceField.Ty (_Item A));
            ("IntoIter", InstanceField.Ty (_IntoIter A));
            ("into_iter", InstanceField.Method (into_iter A))
          ].
    End Impl_core_iter_traits_collect_IntoIterator_where_core_iter_range_Step_A_for_core_range_RangeInclusive_A.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_usize.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "usize" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_usize.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_u8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u8" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_u8.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_u16.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "u16" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_u16.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_isize.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "isize" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_isize.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_i8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i8" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_i8.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_i16.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRange") [] [ Ty.path "i16" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRange_i16.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRangeInclusive_u8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ Ty.path "u8" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRangeInclusive_u8.
    
    Module Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRangeInclusive_i8.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeInclusive") [] [ Ty.path "i8" ].
      
      Axiom Implements :
        M.IsTraitInstance
          "core::iter::traits::exact_size::ExactSizeIterator"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_exact_size_ExactSizeIterator_for_core_range_iter_IterRangeInclusive_i8.
    
    (* StructTuple
      {
        name := "IterRangeFrom";
        const_params := [];
        ty_params := [ "A" ];
        fields := [ Ty.apply (Ty.path "core::ops::range::RangeFrom") [] [ A ] ];
      } *)
    
    Module Impl_core_fmt_Debug_where_core_fmt_Debug_A_for_core_range_iter_IterRangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      (* Debug *)
      Definition fmt (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; f ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let f := M.alloc (| f |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::fmt::Formatter",
                "debug_tuple_field1_finish",
                []
              |),
              [
                M.read (| f |);
                M.read (| Value.String "IterRangeFrom" |);
                M.alloc (|
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "core::range::iter::IterRangeFrom",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::fmt::Debug"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method (fmt A)) ].
    End Impl_core_fmt_Debug_where_core_fmt_Debug_A_for_core_range_iter_IterRangeFrom_A.
    
    Module Impl_core_clone_Clone_where_core_clone_Clone_A_for_core_range_iter_IterRangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      (* Clone *)
      Definition clone (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::range::iter::IterRangeFrom"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.apply (Ty.path "core::ops::range::RangeFrom") [] [ A ],
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_tuple_field (|
                      M.read (| self |),
                      "core::range::iter::IterRangeFrom",
                      0
                    |)
                  ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::clone::Clone"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method (clone A)) ].
    End Impl_core_clone_Clone_where_core_clone_Clone_A_for_core_range_iter_IterRangeFrom_A.
    
    Module Impl_core_range_iter_IterRangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      (*
          pub fn remainder(self) -> RangeFrom<A> {
              RangeFrom { start: self.0.start }
          }
      *)
      Definition remainder (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructRecord
              "core::range::RangeFrom"
              [
                ("start",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.SubPointer.get_struct_tuple_field (|
                        self,
                        "core::range::iter::IterRangeFrom",
                        0
                      |),
                      "core::ops::range::RangeFrom",
                      "start"
                    |)
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_remainder :
        forall (A : Ty.t),
        M.IsAssociatedFunction (Self A) "remainder" (remainder A).
    End Impl_core_range_iter_IterRangeFrom_A.
    
    Module Impl_core_iter_traits_iterator_Iterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      (*     type Item = A; *)
      Definition _Item (A : Ty.t) : Ty.t := A.
      
      (*
          fn next(&mut self) -> Option<A> {
              self.0.next()
          }
      *)
      Definition next (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeFrom") [] [ A ],
                [],
                "next",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeFrom",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn size_hint(&self) -> (usize, Option<usize>) {
              self.0.size_hint()
          }
      *)
      Definition size_hint (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeFrom") [] [ A ],
                [],
                "size_hint",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeFrom",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn nth(&mut self, n: usize) -> Option<A> {
              self.0.nth(n)
          }
      *)
      Definition nth (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self; n ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let n := M.alloc (| n |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::iter::traits::iterator::Iterator",
                Ty.apply (Ty.path "core::ops::range::RangeFrom") [] [ A ],
                [],
                "nth",
                []
              |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::range::iter::IterRangeFrom",
                  0
                |);
                M.read (| n |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::iterator::Iterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("Item", InstanceField.Ty (_Item A));
            ("next", InstanceField.Method (next A));
            ("size_hint", InstanceField.Method (size_hint A));
            ("nth", InstanceField.Method (nth A))
          ].
    End Impl_core_iter_traits_iterator_Iterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeFrom_A.
    
    Module Impl_core_iter_traits_marker_TrustedLen_where_core_iter_traits_marker_TrustedStep_A_for_core_range_iter_IterRangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::marker::TrustedLen"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_marker_TrustedLen_where_core_iter_traits_marker_TrustedStep_A_for_core_range_iter_IterRangeFrom_A.
    
    Module Impl_core_iter_traits_marker_FusedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::marker::FusedIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_iter_traits_marker_FusedIterator_where_core_iter_range_Step_A_for_core_range_iter_IterRangeFrom_A.
    
    Module Impl_core_iter_traits_collect_IntoIterator_where_core_iter_range_Step_A_for_core_range_RangeFrom_A.
      Definition Self (A : Ty.t) : Ty.t := Ty.apply (Ty.path "core::range::RangeFrom") [] [ A ].
      
      (*     type Item = A; *)
      Definition _Item (A : Ty.t) : Ty.t := A.
      
      (*     type IntoIter = IterRangeFrom<A>; *)
      Definition _IntoIter (A : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::range::iter::IterRangeFrom") [] [ A ].
      
      (*
          fn into_iter(self) -> Self::IntoIter {
              IterRangeFrom(self.into())
          }
      *)
      Definition into_iter (A : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self A in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::range::iter::IterRangeFrom"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::convert::Into",
                    Ty.apply (Ty.path "core::range::RangeFrom") [] [ A ],
                    [ Ty.apply (Ty.path "core::ops::range::RangeFrom") [] [ A ] ],
                    "into",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A : Ty.t),
        M.IsTraitInstance
          "core::iter::traits::collect::IntoIterator"
          (Self A)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("Item", InstanceField.Ty (_Item A));
            ("IntoIter", InstanceField.Ty (_IntoIter A));
            ("into_iter", InstanceField.Method (into_iter A))
          ].
    End Impl_core_iter_traits_collect_IntoIterator_where_core_iter_range_Step_A_for_core_range_RangeFrom_A.
  End iter.
End range.
