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

Module hash.
  Module sip.
    (* StructRecord
      {
        name := "SipHasher13";
        const_params := [];
        ty_params := [];
        fields :=
          [
            ("hasher",
              Ty.apply
                (Ty.path "core::hash::sip::Hasher")
                []
                [ Ty.path "core::hash::sip::Sip13Rounds" ])
          ];
      } *)
    
    Module Impl_core_fmt_Debug_for_core_hash_sip_SipHasher13.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher13".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        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_struct_field1_finish",
                []
              |),
              [
                M.read (| f |);
                M.read (| Value.String "SipHasher13" |);
                M.read (| Value.String "hasher" |);
                M.alloc (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "core::hash::sip::SipHasher13",
                    "hasher"
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_core_hash_sip_SipHasher13.
    
    Module Impl_core_clone_Clone_for_core_hash_sip_SipHasher13.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher13".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructRecord
              "core::hash::sip::SipHasher13"
              [
                ("hasher",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip13Rounds" ],
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::SipHasher13",
                        "hasher"
                      |)
                    ]
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_core_hash_sip_SipHasher13.
    
    Module Impl_core_default_Default_for_core_hash_sip_SipHasher13.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher13".
      
      (* Default *)
      Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (Value.StructRecord
              "core::hash::sip::SipHasher13"
              [
                ("hasher",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::default::Default",
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip13Rounds" ],
                      [],
                      "default",
                      []
                    |),
                    []
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::default::Default"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("default", InstanceField.Method default) ].
    End Impl_core_default_Default_for_core_hash_sip_SipHasher13.
    
    (* StructRecord
      {
        name := "SipHasher24";
        const_params := [];
        ty_params := [];
        fields :=
          [
            ("hasher",
              Ty.apply
                (Ty.path "core::hash::sip::Hasher")
                []
                [ Ty.path "core::hash::sip::Sip24Rounds" ])
          ];
      } *)
    
    Module Impl_core_fmt_Debug_for_core_hash_sip_SipHasher24.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher24".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        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_struct_field1_finish",
                []
              |),
              [
                M.read (| f |);
                M.read (| Value.String "SipHasher24" |);
                M.read (| Value.String "hasher" |);
                M.alloc (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "core::hash::sip::SipHasher24",
                    "hasher"
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_core_hash_sip_SipHasher24.
    
    Module Impl_core_clone_Clone_for_core_hash_sip_SipHasher24.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher24".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructRecord
              "core::hash::sip::SipHasher24"
              [
                ("hasher",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::clone::Clone",
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip24Rounds" ],
                      [],
                      "clone",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::SipHasher24",
                        "hasher"
                      |)
                    ]
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_core_hash_sip_SipHasher24.
    
    Module Impl_core_default_Default_for_core_hash_sip_SipHasher24.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher24".
      
      (* Default *)
      Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (Value.StructRecord
              "core::hash::sip::SipHasher24"
              [
                ("hasher",
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::default::Default",
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip24Rounds" ],
                      [],
                      "default",
                      []
                    |),
                    []
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::default::Default"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("default", InstanceField.Method default) ].
    End Impl_core_default_Default_for_core_hash_sip_SipHasher24.
    
    (* StructTuple
      {
        name := "SipHasher";
        const_params := [];
        ty_params := [];
        fields := [ Ty.path "core::hash::sip::SipHasher24" ];
      } *)
    
    Module Impl_core_fmt_Debug_for_core_hash_sip_SipHasher.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        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 "SipHasher" |);
                M.alloc (|
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "core::hash::sip::SipHasher",
                    0
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_core_hash_sip_SipHasher.
    
    Module Impl_core_clone_Clone_for_core_hash_sip_SipHasher.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple
              "core::hash::sip::SipHasher"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::clone::Clone",
                    Ty.path "core::hash::sip::SipHasher24",
                    [],
                    "clone",
                    []
                  |),
                  [
                    M.SubPointer.get_struct_tuple_field (|
                      M.read (| self |),
                      "core::hash::sip::SipHasher",
                      0
                    |)
                  ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_core_hash_sip_SipHasher.
    
    Module Impl_core_default_Default_for_core_hash_sip_SipHasher.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher".
      
      (* Default *)
      Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (Value.StructTuple
              "core::hash::sip::SipHasher"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::default::Default",
                    Ty.path "core::hash::sip::SipHasher24",
                    [],
                    "default",
                    []
                  |),
                  []
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::default::Default"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("default", InstanceField.Method default) ].
    End Impl_core_default_Default_for_core_hash_sip_SipHasher.
    
    (* StructRecord
      {
        name := "Hasher";
        const_params := [];
        ty_params := [ "S" ];
        fields :=
          [
            ("k0", Ty.path "u64");
            ("k1", Ty.path "u64");
            ("length", Ty.path "usize");
            ("state", Ty.path "core::hash::sip::State");
            ("tail", Ty.path "u64");
            ("ntail", Ty.path "usize");
            ("_marker", Ty.apply (Ty.path "core::marker::PhantomData") [] [ S ])
          ];
      } *)
    
    Module Impl_core_fmt_Debug_where_core_fmt_Debug_S_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
      Definition Self (S : Ty.t) : Ty.t := Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ].
      
      (* Debug *)
      Definition fmt (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ self; f ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let f := M.alloc (| f |) in
            M.read (|
              let~ names :=
                M.alloc (|
                  M.alloc (|
                    Value.Array
                      [
                        M.read (| Value.String "k0" |);
                        M.read (| Value.String "k1" |);
                        M.read (| Value.String "length" |);
                        M.read (| Value.String "state" |);
                        M.read (| Value.String "tail" |);
                        M.read (| Value.String "ntail" |);
                        M.read (| Value.String "_marker" |)
                      ]
                  |)
                |) in
              let~ values :=
                M.alloc (|
                  M.alloc (|
                    Value.Array
                      [
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::hash::sip::Hasher",
                          "k0"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::hash::sip::Hasher",
                          "k1"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::hash::sip::Hasher",
                          "length"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::hash::sip::Hasher",
                          "state"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::hash::sip::Hasher",
                          "tail"
                        |);
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::hash::sip::Hasher",
                          "ntail"
                        |);
                        M.alloc (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| self |),
                            "core::hash::sip::Hasher",
                            "_marker"
                          |)
                        |)
                      ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.path "core::fmt::Formatter",
                    "debug_struct_fields_finish",
                    []
                  |),
                  [
                    M.read (| f |);
                    M.read (| Value.String "Hasher" |);
                    M.read (| names |);
                    M.read (| values |)
                  ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (S : Ty.t),
        M.IsTraitInstance
          "core::fmt::Debug"
          (Self S)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method (fmt S)) ].
    End Impl_core_fmt_Debug_where_core_fmt_Debug_S_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
    
    (* StructRecord
      {
        name := "State";
        const_params := [];
        ty_params := [];
        fields :=
          [
            ("v0", Ty.path "u64");
            ("v2", Ty.path "u64");
            ("v1", Ty.path "u64");
            ("v3", Ty.path "u64")
          ];
      } *)
    
    Module Impl_core_fmt_Debug_for_core_hash_sip_State.
      Definition Self : Ty.t := Ty.path "core::hash::sip::State".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        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_struct_field4_finish",
                []
              |),
              [
                M.read (| f |);
                M.read (| Value.String "State" |);
                M.read (| Value.String "v0" |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::hash::sip::State",
                  "v0"
                |);
                M.read (| Value.String "v2" |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::hash::sip::State",
                  "v2"
                |);
                M.read (| Value.String "v1" |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::hash::sip::State",
                  "v1"
                |);
                M.read (| Value.String "v3" |);
                M.alloc (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "core::hash::sip::State",
                    "v3"
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_core_hash_sip_State.
    
    Module Impl_core_clone_Clone_for_core_hash_sip_State.
      Definition Self : Ty.t := Ty.path "core::hash::sip::State".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              M.match_operator (|
                Value.DeclaredButUndefined,
                [ fun γ => ltac:(M.monadic (M.read (| self |))) ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_core_hash_sip_State.
    
    Module Impl_core_marker_Copy_for_core_hash_sip_State.
      Definition Self : Ty.t := Ty.path "core::hash::sip::State".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_core_hash_sip_State.
    
    (*
    unsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {
        debug_assert!(len < 8);
        let mut i = 0; // current byte index (from LSB) in the output u64
        let mut out = 0;
        if i + 3 < len {
            // SAFETY: `i` cannot be greater than `len`, and the caller must guarantee
            // that the index start..start+len is in bounds.
            out = unsafe { load_int_le!(buf, start + i, u32) } as u64;
            i += 4;
        }
        if i + 1 < len {
            // SAFETY: same as above.
            out |= (unsafe { load_int_le!(buf, start + i, u16) } as u64) << (i * 8);
            i += 2
        }
        if i < len {
            // SAFETY: same as above.
            out |= (unsafe { *buf.get_unchecked(start + i) } as u64) << (i * 8);
            i += 1;
        }
        //FIXME(fee1-dead): use debug_assert_eq
        debug_assert!(i == len);
        out
    }
    *)
    Definition u8to64_le (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      match ε, τ, α with
      | [], [], [ buf; start; len ] =>
        ltac:(M.monadic
          (let buf := M.alloc (| buf |) in
          let start := M.alloc (| start |) in
          let len := M.alloc (| len |) in
          M.read (|
            let~ _ :=
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.use (M.alloc (| Value.Bool true |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      let~ _ :=
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      UnOp.not (|
                                        BinOp.lt (|
                                          M.read (| len |),
                                          Value.Integer IntegerKind.Usize 8
                                        |)
                                      |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                M.alloc (|
                                  M.never_to_any (|
                                    M.call_closure (|
                                      M.get_function (| "core::panicking::panic", [] |),
                                      [ M.read (| Value.String "assertion failed: len < 8" |) ]
                                    |)
                                  |)
                                |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |) in
                      M.alloc (| Value.Tuple [] |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                ]
              |) in
            let~ i := M.alloc (| Value.Integer IntegerKind.Usize 0 |) in
            let~ out := M.alloc (| Value.Integer IntegerKind.U64 0 |) in
            let~ _ :=
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.use
                          (M.alloc (|
                            BinOp.lt (|
                              BinOp.Wrap.add (|
                                M.read (| i |),
                                Value.Integer IntegerKind.Usize 3
                              |),
                              M.read (| len |)
                            |)
                          |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      let~ _ :=
                        M.write (|
                          out,
                          M.rust_cast
                            (M.read (|
                              let~ _ :=
                                M.match_operator (|
                                  M.alloc (| Value.Tuple [] |),
                                  [
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                        let _ :=
                                          M.is_constant_or_break_match (|
                                            M.read (| γ |),
                                            Value.Bool true
                                          |) in
                                        let~ _ :=
                                          M.match_operator (|
                                            M.alloc (| Value.Tuple [] |),
                                            [
                                              fun γ =>
                                                ltac:(M.monadic
                                                  (let γ :=
                                                    M.use
                                                      (M.alloc (|
                                                        UnOp.not (|
                                                          BinOp.le (|
                                                            BinOp.Wrap.add (|
                                                              BinOp.Wrap.add (|
                                                                M.read (| start |),
                                                                M.read (| i |)
                                                              |),
                                                              M.call_closure (|
                                                                M.get_function (|
                                                                  "core::mem::size_of",
                                                                  [ Ty.path "u32" ]
                                                                |),
                                                                []
                                                              |)
                                                            |),
                                                            M.call_closure (|
                                                              M.get_associated_function (|
                                                                Ty.apply
                                                                  (Ty.path "slice")
                                                                  []
                                                                  [ Ty.path "u8" ],
                                                                "len",
                                                                []
                                                              |),
                                                              [ M.read (| buf |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)) in
                                                  let _ :=
                                                    M.is_constant_or_break_match (|
                                                      M.read (| γ |),
                                                      Value.Bool true
                                                    |) in
                                                  M.alloc (|
                                                    M.never_to_any (|
                                                      M.call_closure (|
                                                        M.get_function (|
                                                          "core::panicking::panic",
                                                          []
                                                        |),
                                                        [
                                                          M.read (|
                                                            Value.String
                                                              "assertion failed: start + i + mem::size_of::<u32>() <= buf.len()"
                                                          |)
                                                        ]
                                                      |)
                                                    |)
                                                  |)));
                                              fun γ =>
                                                ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                            ]
                                          |) in
                                        M.alloc (| Value.Tuple [] |)));
                                    fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                  ]
                                |) in
                              let~ data :=
                                M.copy (|
                                  M.use (M.alloc (| Value.Integer IntegerKind.U32 0 |))
                                |) in
                              let~ _ :=
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_function (|
                                      "core::intrinsics::copy_nonoverlapping",
                                      [ Ty.path "u8" ]
                                    |),
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                          "add",
                                          []
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                                              "as_ptr",
                                              []
                                            |),
                                            [ M.read (| buf |) ]
                                          |);
                                          BinOp.Wrap.add (| M.read (| start |), M.read (| i |) |)
                                        ]
                                      |);
                                      M.rust_cast (M.read (| M.use (M.alloc (| data |)) |));
                                      M.call_closure (|
                                        M.get_function (|
                                          "core::mem::size_of",
                                          [ Ty.path "u32" ]
                                        |),
                                        []
                                      |)
                                    ]
                                  |)
                                |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (| Ty.path "u32", "to_le", [] |),
                                  [ M.read (| data |) ]
                                |)
                              |)
                            |))
                        |) in
                      let~ _ :=
                        let β := i in
                        M.write (|
                          β,
                          BinOp.Wrap.add (| M.read (| β |), Value.Integer IntegerKind.Usize 4 |)
                        |) in
                      M.alloc (| Value.Tuple [] |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                ]
              |) in
            let~ _ :=
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.use
                          (M.alloc (|
                            BinOp.lt (|
                              BinOp.Wrap.add (|
                                M.read (| i |),
                                Value.Integer IntegerKind.Usize 1
                              |),
                              M.read (| len |)
                            |)
                          |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      let~ _ :=
                        let β := out in
                        M.write (|
                          β,
                          BinOp.bit_or
                            (M.read (| β |))
                            (BinOp.Wrap.shl (|
                              M.rust_cast
                                (M.read (|
                                  let~ _ :=
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            let~ _ :=
                                              M.match_operator (|
                                                M.alloc (| Value.Tuple [] |),
                                                [
                                                  fun γ =>
                                                    ltac:(M.monadic
                                                      (let γ :=
                                                        M.use
                                                          (M.alloc (|
                                                            UnOp.not (|
                                                              BinOp.le (|
                                                                BinOp.Wrap.add (|
                                                                  BinOp.Wrap.add (|
                                                                    M.read (| start |),
                                                                    M.read (| i |)
                                                                  |),
                                                                  M.call_closure (|
                                                                    M.get_function (|
                                                                      "core::mem::size_of",
                                                                      [ Ty.path "u16" ]
                                                                    |),
                                                                    []
                                                                  |)
                                                                |),
                                                                M.call_closure (|
                                                                  M.get_associated_function (|
                                                                    Ty.apply
                                                                      (Ty.path "slice")
                                                                      []
                                                                      [ Ty.path "u8" ],
                                                                    "len",
                                                                    []
                                                                  |),
                                                                  [ M.read (| buf |) ]
                                                                |)
                                                              |)
                                                            |)
                                                          |)) in
                                                      let _ :=
                                                        M.is_constant_or_break_match (|
                                                          M.read (| γ |),
                                                          Value.Bool true
                                                        |) in
                                                      M.alloc (|
                                                        M.never_to_any (|
                                                          M.call_closure (|
                                                            M.get_function (|
                                                              "core::panicking::panic",
                                                              []
                                                            |),
                                                            [
                                                              M.read (|
                                                                Value.String
                                                                  "assertion failed: start + i + mem::size_of::<u16>() <= buf.len()"
                                                              |)
                                                            ]
                                                          |)
                                                        |)
                                                      |)));
                                                  fun γ =>
                                                    ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                                ]
                                              |) in
                                            M.alloc (| Value.Tuple [] |)));
                                        fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                      ]
                                    |) in
                                  let~ data :=
                                    M.copy (|
                                      M.use (M.alloc (| Value.Integer IntegerKind.U16 0 |))
                                    |) in
                                  let~ _ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_function (|
                                          "core::intrinsics::copy_nonoverlapping",
                                          [ Ty.path "u8" ]
                                        |),
                                        [
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                              "add",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                                                  "as_ptr",
                                                  []
                                                |),
                                                [ M.read (| buf |) ]
                                              |);
                                              BinOp.Wrap.add (|
                                                M.read (| start |),
                                                M.read (| i |)
                                              |)
                                            ]
                                          |);
                                          M.rust_cast (M.read (| M.use (M.alloc (| data |)) |));
                                          M.call_closure (|
                                            M.get_function (|
                                              "core::mem::size_of",
                                              [ Ty.path "u16" ]
                                            |),
                                            []
                                          |)
                                        ]
                                      |)
                                    |) in
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_associated_function (| Ty.path "u16", "to_le", [] |),
                                      [ M.read (| data |) ]
                                    |)
                                  |)
                                |)),
                              BinOp.Wrap.mul (| M.read (| i |), Value.Integer IntegerKind.Usize 8 |)
                            |))
                        |) in
                      let β := i in
                      M.write (|
                        β,
                        BinOp.Wrap.add (| M.read (| β |), Value.Integer IntegerKind.Usize 2 |)
                      |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                ]
              |) in
            let~ _ :=
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.use (M.alloc (| BinOp.lt (| M.read (| i |), M.read (| len |) |) |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      let~ _ :=
                        let β := out in
                        M.write (|
                          β,
                          BinOp.bit_or
                            (M.read (| β |))
                            (BinOp.Wrap.shl (|
                              M.rust_cast
                                (M.read (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                                      "get_unchecked",
                                      [ Ty.path "usize" ]
                                    |),
                                    [
                                      M.read (| buf |);
                                      BinOp.Wrap.add (| M.read (| start |), M.read (| i |) |)
                                    ]
                                  |)
                                |)),
                              BinOp.Wrap.mul (| M.read (| i |), Value.Integer IntegerKind.Usize 8 |)
                            |))
                        |) in
                      let~ _ :=
                        let β := i in
                        M.write (|
                          β,
                          BinOp.Wrap.add (| M.read (| β |), Value.Integer IntegerKind.Usize 1 |)
                        |) in
                      M.alloc (| Value.Tuple [] |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                ]
              |) in
            let~ _ :=
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.use (M.alloc (| Value.Bool true |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      let~ _ :=
                        M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      UnOp.not (| BinOp.eq (| M.read (| i |), M.read (| len |) |) |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                M.alloc (|
                                  M.never_to_any (|
                                    M.call_closure (|
                                      M.get_function (| "core::panicking::panic", [] |),
                                      [ M.read (| Value.String "assertion failed: i == len" |) ]
                                    |)
                                  |)
                                |)));
                            fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                          ]
                        |) in
                      M.alloc (| Value.Tuple [] |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                ]
              |) in
            out
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Function_u8to64_le : M.IsFunction "core::hash::sip::u8to64_le" u8to64_le.
    
    Module Impl_core_hash_sip_SipHasher.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher".
      
      (*
          pub const fn new() -> SipHasher {
              SipHasher::new_with_keys(0, 0)
          }
      *)
      Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::hash::sip::SipHasher",
                "new_with_keys",
                []
              |),
              [ Value.Integer IntegerKind.U64 0; Value.Integer IntegerKind.U64 0 ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
      
      (*
          pub const fn new_with_keys(key0: u64, key1: u64) -> SipHasher {
              SipHasher(SipHasher24 { hasher: Hasher::new_with_keys(key0, key1) })
          }
      *)
      Definition new_with_keys (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ key0; key1 ] =>
          ltac:(M.monadic
            (let key0 := M.alloc (| key0 |) in
            let key1 := M.alloc (| key1 |) in
            Value.StructTuple
              "core::hash::sip::SipHasher"
              [
                Value.StructRecord
                  "core::hash::sip::SipHasher24"
                  [
                    ("hasher",
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply
                            (Ty.path "core::hash::sip::Hasher")
                            []
                            [ Ty.path "core::hash::sip::Sip24Rounds" ],
                          "new_with_keys",
                          []
                        |),
                        [ M.read (| key0 |); M.read (| key1 |) ]
                      |))
                  ]
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new_with_keys :
        M.IsAssociatedFunction Self "new_with_keys" new_with_keys.
    End Impl_core_hash_sip_SipHasher.
    
    Module Impl_core_hash_sip_SipHasher13.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher13".
      
      (*
          pub const fn new() -> SipHasher13 {
              SipHasher13::new_with_keys(0, 0)
          }
      *)
      Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::hash::sip::SipHasher13",
                "new_with_keys",
                []
              |),
              [ Value.Integer IntegerKind.U64 0; Value.Integer IntegerKind.U64 0 ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
      
      (*
          pub const fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 {
              SipHasher13 { hasher: Hasher::new_with_keys(key0, key1) }
          }
      *)
      Definition new_with_keys (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ key0; key1 ] =>
          ltac:(M.monadic
            (let key0 := M.alloc (| key0 |) in
            let key1 := M.alloc (| key1 |) in
            Value.StructRecord
              "core::hash::sip::SipHasher13"
              [
                ("hasher",
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip13Rounds" ],
                      "new_with_keys",
                      []
                    |),
                    [ M.read (| key0 |); M.read (| key1 |) ]
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new_with_keys :
        M.IsAssociatedFunction Self "new_with_keys" new_with_keys.
    End Impl_core_hash_sip_SipHasher13.
    
    Module Impl_core_hash_sip_Hasher_S.
      Definition Self (S : Ty.t) : Ty.t := Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ].
      
      (*
          const fn new_with_keys(key0: u64, key1: u64) -> Hasher<S> {
              let mut state = Hasher {
                  k0: key0,
                  k1: key1,
                  length: 0,
                  state: State { v0: 0, v1: 0, v2: 0, v3: 0 },
                  tail: 0,
                  ntail: 0,
                  _marker: PhantomData,
              };
              state.reset();
              state
          }
      *)
      Definition new_with_keys
          (S : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ key0; key1 ] =>
          ltac:(M.monadic
            (let key0 := M.alloc (| key0 |) in
            let key1 := M.alloc (| key1 |) in
            M.read (|
              let~ state :=
                M.alloc (|
                  Value.StructRecord
                    "core::hash::sip::Hasher"
                    [
                      ("k0", M.read (| key0 |));
                      ("k1", M.read (| key1 |));
                      ("length", Value.Integer IntegerKind.Usize 0);
                      ("state",
                        Value.StructRecord
                          "core::hash::sip::State"
                          [
                            ("v0", Value.Integer IntegerKind.U64 0);
                            ("v1", Value.Integer IntegerKind.U64 0);
                            ("v2", Value.Integer IntegerKind.U64 0);
                            ("v3", Value.Integer IntegerKind.U64 0)
                          ]);
                      ("tail", Value.Integer IntegerKind.U64 0);
                      ("ntail", Value.Integer IntegerKind.Usize 0);
                      ("_marker", Value.StructTuple "core::marker::PhantomData" [])
                    ]
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ],
                      "reset",
                      []
                    |),
                    [ state ]
                  |)
                |) in
              state
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new_with_keys :
        forall (S : Ty.t),
        M.IsAssociatedFunction (Self S) "new_with_keys" (new_with_keys S).
      
      (*
          const fn reset(&mut self) {
              self.length = 0;
              self.state.v0 = self.k0 ^ 0x736f6d6570736575;
              self.state.v1 = self.k1 ^ 0x646f72616e646f6d;
              self.state.v2 = self.k0 ^ 0x6c7967656e657261;
              self.state.v3 = self.k1 ^ 0x7465646279746573;
              self.ntail = 0;
          }
      *)
      Definition reset (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              let~ _ :=
                M.write (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "core::hash::sip::Hasher",
                    "length"
                  |),
                  Value.Integer IntegerKind.Usize 0
                |) in
              let~ _ :=
                M.write (|
                  M.SubPointer.get_struct_record_field (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "state"
                    |),
                    "core::hash::sip::State",
                    "v0"
                  |),
                  BinOp.bit_xor
                    (M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "k0"
                      |)
                    |))
                    (Value.Integer IntegerKind.U64 8317987319222330741)
                |) in
              let~ _ :=
                M.write (|
                  M.SubPointer.get_struct_record_field (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "state"
                    |),
                    "core::hash::sip::State",
                    "v1"
                  |),
                  BinOp.bit_xor
                    (M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "k1"
                      |)
                    |))
                    (Value.Integer IntegerKind.U64 7237128888997146477)
                |) in
              let~ _ :=
                M.write (|
                  M.SubPointer.get_struct_record_field (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "state"
                    |),
                    "core::hash::sip::State",
                    "v2"
                  |),
                  BinOp.bit_xor
                    (M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "k0"
                      |)
                    |))
                    (Value.Integer IntegerKind.U64 7816392313619706465)
                |) in
              let~ _ :=
                M.write (|
                  M.SubPointer.get_struct_record_field (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "state"
                    |),
                    "core::hash::sip::State",
                    "v3"
                  |),
                  BinOp.bit_xor
                    (M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "k1"
                      |)
                    |))
                    (Value.Integer IntegerKind.U64 8387220255154660723)
                |) in
              let~ _ :=
                M.write (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "core::hash::sip::Hasher",
                    "ntail"
                  |),
                  Value.Integer IntegerKind.Usize 0
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_reset :
        forall (S : Ty.t),
        M.IsAssociatedFunction (Self S) "reset" (reset S).
    End Impl_core_hash_sip_Hasher_S.
    
    Module Impl_core_hash_Hasher_for_core_hash_sip_SipHasher.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher".
      
      (*
          fn write(&mut self, msg: &[u8]) {
              self.0.hasher.write(msg)
          }
      *)
      Definition write (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; msg ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let msg := M.alloc (| msg |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::hash::Hasher",
                Ty.apply
                  (Ty.path "core::hash::sip::Hasher")
                  []
                  [ Ty.path "core::hash::sip::Sip24Rounds" ],
                [],
                "write",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "core::hash::sip::SipHasher",
                    0
                  |),
                  "core::hash::sip::SipHasher24",
                  "hasher"
                |);
                M.read (| msg |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn write_str(&mut self, s: &str) {
              self.0.hasher.write_str(s);
          }
      *)
      Definition write_str (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; s ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let s := M.alloc (| s |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hasher",
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip24Rounds" ],
                      [],
                      "write_str",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.SubPointer.get_struct_tuple_field (|
                          M.read (| self |),
                          "core::hash::sip::SipHasher",
                          0
                        |),
                        "core::hash::sip::SipHasher24",
                        "hasher"
                      |);
                      M.read (| s |)
                    ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn finish(&self) -> u64 {
              self.0.hasher.finish()
          }
      *)
      Definition finish (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::hash::Hasher",
                Ty.apply
                  (Ty.path "core::hash::sip::Hasher")
                  []
                  [ Ty.path "core::hash::sip::Sip24Rounds" ],
                [],
                "finish",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.SubPointer.get_struct_tuple_field (|
                    M.read (| self |),
                    "core::hash::sip::SipHasher",
                    0
                  |),
                  "core::hash::sip::SipHasher24",
                  "hasher"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hasher"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("write", InstanceField.Method write);
            ("write_str", InstanceField.Method write_str);
            ("finish", InstanceField.Method finish)
          ].
    End Impl_core_hash_Hasher_for_core_hash_sip_SipHasher.
    
    Module Impl_core_hash_Hasher_for_core_hash_sip_SipHasher13.
      Definition Self : Ty.t := Ty.path "core::hash::sip::SipHasher13".
      
      (*
          fn write(&mut self, msg: &[u8]) {
              self.hasher.write(msg)
          }
      *)
      Definition write (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; msg ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let msg := M.alloc (| msg |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::hash::Hasher",
                Ty.apply
                  (Ty.path "core::hash::sip::Hasher")
                  []
                  [ Ty.path "core::hash::sip::Sip13Rounds" ],
                [],
                "write",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::hash::sip::SipHasher13",
                  "hasher"
                |);
                M.read (| msg |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn write_str(&mut self, s: &str) {
              self.hasher.write_str(s);
          }
      *)
      Definition write_str (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; s ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let s := M.alloc (| s |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hasher",
                      Ty.apply
                        (Ty.path "core::hash::sip::Hasher")
                        []
                        [ Ty.path "core::hash::sip::Sip13Rounds" ],
                      [],
                      "write_str",
                      []
                    |),
                    [
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::SipHasher13",
                        "hasher"
                      |);
                      M.read (| s |)
                    ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn finish(&self) -> u64 {
              self.hasher.finish()
          }
      *)
      Definition finish (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::hash::Hasher",
                Ty.apply
                  (Ty.path "core::hash::sip::Hasher")
                  []
                  [ Ty.path "core::hash::sip::Sip13Rounds" ],
                [],
                "finish",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::hash::sip::SipHasher13",
                  "hasher"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hasher"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("write", InstanceField.Method write);
            ("write_str", InstanceField.Method write_str);
            ("finish", InstanceField.Method finish)
          ].
    End Impl_core_hash_Hasher_for_core_hash_sip_SipHasher13.
    
    Module Impl_core_hash_Hasher_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
      Definition Self (S : Ty.t) : Ty.t := Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ].
      
      (*
          fn write(&mut self, msg: &[u8]) {
              let length = msg.len();
              self.length += length;
      
              let mut needed = 0;
      
              if self.ntail != 0 {
                  needed = 8 - self.ntail;
                  // SAFETY: `cmp::min(length, needed)` is guaranteed to not be over `length`
                  self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << (8 * self.ntail);
                  if length < needed {
                      self.ntail += length;
                      return;
                  } else {
                      self.state.v3 ^= self.tail;
                      S::c_rounds(&mut self.state);
                      self.state.v0 ^= self.tail;
                      self.ntail = 0;
                  }
              }
      
              // Buffered tail is now flushed, process new input.
              let len = length - needed;
              let left = len & 0x7; // len % 8
      
              let mut i = needed;
              while i < len - left {
                  // SAFETY: because `len - left` is the biggest multiple of 8 under
                  // `len`, and because `i` starts at `needed` where `len` is `length - needed`,
                  // `i + 8` is guaranteed to be less than or equal to `length`.
                  let mi = unsafe { load_int_le!(msg, i, u64) };
      
                  self.state.v3 ^= mi;
                  S::c_rounds(&mut self.state);
                  self.state.v0 ^= mi;
      
                  i += 8;
              }
      
              // SAFETY: `i` is now `needed + len.div_euclid(8) * 8`,
              // so `i + left` = `needed + len` = `length`, which is by
              // definition equal to `msg.len()`.
              self.tail = unsafe { u8to64_le(msg, i, left) };
              self.ntail = left;
          }
      *)
      Definition write (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ self; msg ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let msg := M.alloc (| msg |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ length :=
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                          "len",
                          []
                        |),
                        [ M.read (| msg |) ]
                      |)
                    |) in
                  let~ _ :=
                    let β :=
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "length"
                      |) in
                    M.write (| β, BinOp.Wrap.add (| M.read (| β |), M.read (| length |) |) |) in
                  let~ needed := M.alloc (| Value.Integer IntegerKind.Usize 0 |) in
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  BinOp.ne (|
                                    M.read (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| self |),
                                        "core::hash::sip::Hasher",
                                        "ntail"
                                      |)
                                    |),
                                    Value.Integer IntegerKind.Usize 0
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            let~ _ :=
                              M.write (|
                                needed,
                                BinOp.Wrap.sub (|
                                  Value.Integer IntegerKind.Usize 8,
                                  M.read (|
                                    M.SubPointer.get_struct_record_field (|
                                      M.read (| self |),
                                      "core::hash::sip::Hasher",
                                      "ntail"
                                    |)
                                  |)
                                |)
                              |) in
                            let~ _ :=
                              let β :=
                                M.SubPointer.get_struct_record_field (|
                                  M.read (| self |),
                                  "core::hash::sip::Hasher",
                                  "tail"
                                |) in
                              M.write (|
                                β,
                                BinOp.bit_or
                                  (M.read (| β |))
                                  (BinOp.Wrap.shl (|
                                    M.call_closure (|
                                      M.get_function (| "core::hash::sip::u8to64_le", [] |),
                                      [
                                        M.read (| msg |);
                                        Value.Integer IntegerKind.Usize 0;
                                        M.call_closure (|
                                          M.get_function (|
                                            "core::cmp::min",
                                            [ Ty.path "usize" ]
                                          |),
                                          [ M.read (| length |); M.read (| needed |) ]
                                        |)
                                      ]
                                    |),
                                    BinOp.Wrap.mul (|
                                      Value.Integer IntegerKind.Usize 8,
                                      M.read (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| self |),
                                          "core::hash::sip::Hasher",
                                          "ntail"
                                        |)
                                      |)
                                    |)
                                  |))
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          BinOp.lt (| M.read (| length |), M.read (| needed |) |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.never_to_any (|
                                        M.read (|
                                          let~ _ :=
                                            let β :=
                                              M.SubPointer.get_struct_record_field (|
                                                M.read (| self |),
                                                "core::hash::sip::Hasher",
                                                "ntail"
                                              |) in
                                            M.write (|
                                              β,
                                              BinOp.Wrap.add (|
                                                M.read (| β |),
                                                M.read (| length |)
                                              |)
                                            |) in
                                          M.return_ (| Value.Tuple [] |)
                                        |)
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ _ :=
                                      let β :=
                                        M.SubPointer.get_struct_record_field (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| self |),
                                            "core::hash::sip::Hasher",
                                            "state"
                                          |),
                                          "core::hash::sip::State",
                                          "v3"
                                        |) in
                                      M.write (|
                                        β,
                                        BinOp.bit_xor
                                          (M.read (| β |))
                                          (M.read (|
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| self |),
                                              "core::hash::sip::Hasher",
                                              "tail"
                                            |)
                                          |))
                                      |) in
                                    let~ _ :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::hash::sip::Sip",
                                            S,
                                            [],
                                            "c_rounds",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| self |),
                                              "core::hash::sip::Hasher",
                                              "state"
                                            |)
                                          ]
                                        |)
                                      |) in
                                    let~ _ :=
                                      let β :=
                                        M.SubPointer.get_struct_record_field (|
                                          M.SubPointer.get_struct_record_field (|
                                            M.read (| self |),
                                            "core::hash::sip::Hasher",
                                            "state"
                                          |),
                                          "core::hash::sip::State",
                                          "v0"
                                        |) in
                                      M.write (|
                                        β,
                                        BinOp.bit_xor
                                          (M.read (| β |))
                                          (M.read (|
                                            M.SubPointer.get_struct_record_field (|
                                              M.read (| self |),
                                              "core::hash::sip::Hasher",
                                              "tail"
                                            |)
                                          |))
                                      |) in
                                    let~ _ :=
                                      M.write (|
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| self |),
                                          "core::hash::sip::Hasher",
                                          "ntail"
                                        |),
                                        Value.Integer IntegerKind.Usize 0
                                      |) in
                                    M.alloc (| Value.Tuple [] |)))
                              ]
                            |)));
                        fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                      ]
                    |) in
                  let~ len :=
                    M.alloc (| BinOp.Wrap.sub (| M.read (| length |), M.read (| needed |) |) |) in
                  let~ left :=
                    M.alloc (|
                      BinOp.bit_and (M.read (| len |)) (Value.Integer IntegerKind.Usize 7)
                    |) in
                  let~ i := M.copy (| needed |) in
                  let~ _ :=
                    M.loop (|
                      ltac:(M.monadic
                        (M.match_operator (|
                          M.alloc (| Value.Tuple [] |),
                          [
                            fun γ =>
                              ltac:(M.monadic
                                (let γ :=
                                  M.use
                                    (M.alloc (|
                                      BinOp.lt (|
                                        M.read (| i |),
                                        BinOp.Wrap.sub (| M.read (| len |), M.read (| left |) |)
                                      |)
                                    |)) in
                                let _ :=
                                  M.is_constant_or_break_match (|
                                    M.read (| γ |),
                                    Value.Bool true
                                  |) in
                                let~ mi :=
                                  M.copy (|
                                    let~ _ :=
                                      M.match_operator (|
                                        M.alloc (| Value.Tuple [] |),
                                        [
                                          fun γ =>
                                            ltac:(M.monadic
                                              (let γ := M.use (M.alloc (| Value.Bool true |)) in
                                              let _ :=
                                                M.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) in
                                              let~ _ :=
                                                M.match_operator (|
                                                  M.alloc (| Value.Tuple [] |),
                                                  [
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (let γ :=
                                                          M.use
                                                            (M.alloc (|
                                                              UnOp.not (|
                                                                BinOp.le (|
                                                                  BinOp.Wrap.add (|
                                                                    M.read (| i |),
                                                                    M.call_closure (|
                                                                      M.get_function (|
                                                                        "core::mem::size_of",
                                                                        [ Ty.path "u64" ]
                                                                      |),
                                                                      []
                                                                    |)
                                                                  |),
                                                                  M.call_closure (|
                                                                    M.get_associated_function (|
                                                                      Ty.apply
                                                                        (Ty.path "slice")
                                                                        []
                                                                        [ Ty.path "u8" ],
                                                                      "len",
                                                                      []
                                                                    |),
                                                                    [ M.read (| msg |) ]
                                                                  |)
                                                                |)
                                                              |)
                                                            |)) in
                                                        let _ :=
                                                          M.is_constant_or_break_match (|
                                                            M.read (| γ |),
                                                            Value.Bool true
                                                          |) in
                                                        M.alloc (|
                                                          M.never_to_any (|
                                                            M.call_closure (|
                                                              M.get_function (|
                                                                "core::panicking::panic",
                                                                []
                                                              |),
                                                              [
                                                                M.read (|
                                                                  Value.String
                                                                    "assertion failed: i + mem::size_of::<u64>() <= msg.len()"
                                                                |)
                                                              ]
                                                            |)
                                                          |)
                                                        |)));
                                                    fun γ =>
                                                      ltac:(M.monadic
                                                        (M.alloc (| Value.Tuple [] |)))
                                                  ]
                                                |) in
                                              M.alloc (| Value.Tuple [] |)));
                                          fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                                        ]
                                      |) in
                                    let~ data :=
                                      M.copy (|
                                        M.use (M.alloc (| Value.Integer IntegerKind.U64 0 |))
                                      |) in
                                    let~ _ :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_function (|
                                            "core::intrinsics::copy_nonoverlapping",
                                            [ Ty.path "u8" ]
                                          |),
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.apply (Ty.path "*const") [] [ Ty.path "u8" ],
                                                "add",
                                                []
                                              |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.apply (Ty.path "slice") [] [ Ty.path "u8" ],
                                                    "as_ptr",
                                                    []
                                                  |),
                                                  [ M.read (| msg |) ]
                                                |);
                                                M.read (| i |)
                                              ]
                                            |);
                                            M.rust_cast (M.read (| M.use (M.alloc (| data |)) |));
                                            M.call_closure (|
                                              M.get_function (|
                                                "core::mem::size_of",
                                                [ Ty.path "u64" ]
                                              |),
                                              []
                                            |)
                                          ]
                                        |)
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (| Ty.path "u64", "to_le", [] |),
                                        [ M.read (| data |) ]
                                      |)
                                    |)
                                  |) in
                                let~ _ :=
                                  let β :=
                                    M.SubPointer.get_struct_record_field (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| self |),
                                        "core::hash::sip::Hasher",
                                        "state"
                                      |),
                                      "core::hash::sip::State",
                                      "v3"
                                    |) in
                                  M.write (|
                                    β,
                                    BinOp.bit_xor (M.read (| β |)) (M.read (| mi |))
                                  |) in
                                let~ _ :=
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::hash::sip::Sip",
                                        S,
                                        [],
                                        "c_rounds",
                                        []
                                      |),
                                      [
                                        M.SubPointer.get_struct_record_field (|
                                          M.read (| self |),
                                          "core::hash::sip::Hasher",
                                          "state"
                                        |)
                                      ]
                                    |)
                                  |) in
                                let~ _ :=
                                  let β :=
                                    M.SubPointer.get_struct_record_field (|
                                      M.SubPointer.get_struct_record_field (|
                                        M.read (| self |),
                                        "core::hash::sip::Hasher",
                                        "state"
                                      |),
                                      "core::hash::sip::State",
                                      "v0"
                                    |) in
                                  M.write (|
                                    β,
                                    BinOp.bit_xor (M.read (| β |)) (M.read (| mi |))
                                  |) in
                                let~ _ :=
                                  let β := i in
                                  M.write (|
                                    β,
                                    BinOp.Wrap.add (|
                                      M.read (| β |),
                                      Value.Integer IntegerKind.Usize 8
                                    |)
                                  |) in
                                M.alloc (| Value.Tuple [] |)));
                            fun γ =>
                              ltac:(M.monadic
                                (M.alloc (|
                                  M.never_to_any (|
                                    M.read (|
                                      let~ _ :=
                                        M.alloc (|
                                          M.never_to_any (| M.read (| M.break (||) |) |)
                                        |) in
                                      M.alloc (| Value.Tuple [] |)
                                    |)
                                  |)
                                |)))
                          ]
                        |)))
                    |) in
                  let~ _ :=
                    M.write (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "tail"
                      |),
                      M.call_closure (|
                        M.get_function (| "core::hash::sip::u8to64_le", [] |),
                        [ M.read (| msg |); M.read (| i |); M.read (| left |) ]
                      |)
                    |) in
                  let~ _ :=
                    M.write (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "ntail"
                      |),
                      M.read (| left |)
                    |) in
                  M.alloc (| Value.Tuple [] |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn write_str(&mut self, s: &str) {
              // This hasher works byte-wise, and `0xFF` cannot show up in a `str`,
              // so just hashing the one extra byte is enough to be prefix-free.
              self.write(s.as_bytes());
              self.write_u8(0xFF);
          }
      *)
      Definition write_str (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ self; s ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let s := M.alloc (| s |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hasher",
                      Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ],
                      [],
                      "write",
                      []
                    |),
                    [
                      M.read (| self |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "str", "as_bytes", [] |),
                        [ M.read (| s |) ]
                      |)
                    ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hasher",
                      Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ],
                      [],
                      "write_u8",
                      []
                    |),
                    [ M.read (| self |); Value.Integer IntegerKind.U8 255 ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn finish(&self) -> u64 {
              let mut state = self.state;
      
              let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;
      
              state.v3 ^= b;
              S::c_rounds(&mut state);
              state.v0 ^= b;
      
              state.v2 ^= 0xff;
              S::d_rounds(&mut state);
      
              state.v0 ^ state.v1 ^ state.v2 ^ state.v3
          }
      *)
      Definition finish (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              let~ state :=
                M.copy (|
                  M.SubPointer.get_struct_record_field (|
                    M.read (| self |),
                    "core::hash::sip::Hasher",
                    "state"
                  |)
                |) in
              let~ b :=
                M.alloc (|
                  BinOp.bit_or
                    (BinOp.Wrap.shl (|
                      BinOp.bit_and
                        (M.rust_cast
                          (M.read (|
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "core::hash::sip::Hasher",
                              "length"
                            |)
                          |)))
                        (Value.Integer IntegerKind.U64 255),
                      Value.Integer IntegerKind.I32 56
                    |))
                    (M.read (|
                      M.SubPointer.get_struct_record_field (|
                        M.read (| self |),
                        "core::hash::sip::Hasher",
                        "tail"
                      |)
                    |))
                |) in
              let~ _ :=
                let β :=
                  M.SubPointer.get_struct_record_field (|
                    state,
                    "core::hash::sip::State",
                    "v3"
                  |) in
                M.write (| β, BinOp.bit_xor (M.read (| β |)) (M.read (| b |)) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::hash::sip::Sip", S, [], "c_rounds", [] |),
                    [ state ]
                  |)
                |) in
              let~ _ :=
                let β :=
                  M.SubPointer.get_struct_record_field (|
                    state,
                    "core::hash::sip::State",
                    "v0"
                  |) in
                M.write (| β, BinOp.bit_xor (M.read (| β |)) (M.read (| b |)) |) in
              let~ _ :=
                let β :=
                  M.SubPointer.get_struct_record_field (|
                    state,
                    "core::hash::sip::State",
                    "v2"
                  |) in
                M.write (|
                  β,
                  BinOp.bit_xor (M.read (| β |)) (Value.Integer IntegerKind.U64 255)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::hash::sip::Sip", S, [], "d_rounds", [] |),
                    [ state ]
                  |)
                |) in
              M.alloc (|
                BinOp.bit_xor
                  (BinOp.bit_xor
                    (BinOp.bit_xor
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          state,
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          state,
                          "core::hash::sip::State",
                          "v1"
                        |)
                      |)))
                    (M.read (|
                      M.SubPointer.get_struct_record_field (|
                        state,
                        "core::hash::sip::State",
                        "v2"
                      |)
                    |)))
                  (M.read (|
                    M.SubPointer.get_struct_record_field (| state, "core::hash::sip::State", "v3" |)
                  |))
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (S : Ty.t),
        M.IsTraitInstance
          "core::hash::Hasher"
          (Self S)
          (* Trait polymorphic types *) []
          (* Instance *)
          [
            ("write", InstanceField.Method (write S));
            ("write_str", InstanceField.Method (write_str S));
            ("finish", InstanceField.Method (finish S))
          ].
    End Impl_core_hash_Hasher_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
    
    Module Impl_core_clone_Clone_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
      Definition Self (S : Ty.t) : Ty.t := Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ].
      
      (*
          fn clone(&self) -> Hasher<S> {
              Hasher {
                  k0: self.k0,
                  k1: self.k1,
                  length: self.length,
                  state: self.state,
                  tail: self.tail,
                  ntail: self.ntail,
                  _marker: self._marker,
              }
          }
      *)
      Definition clone (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructRecord
              "core::hash::sip::Hasher"
              [
                ("k0",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "k0"
                    |)
                  |));
                ("k1",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "k1"
                    |)
                  |));
                ("length",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "length"
                    |)
                  |));
                ("state",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "state"
                    |)
                  |));
                ("tail",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "tail"
                    |)
                  |));
                ("ntail",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "ntail"
                    |)
                  |));
                ("_marker",
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::hash::sip::Hasher",
                      "_marker"
                    |)
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (S : Ty.t),
        M.IsTraitInstance
          "core::clone::Clone"
          (Self S)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method (clone S)) ].
    End Impl_core_clone_Clone_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
    
    Module Impl_core_default_Default_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
      Definition Self (S : Ty.t) : Ty.t := Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ].
      
      (*
          fn default() -> Hasher<S> {
              Hasher::new_with_keys(0, 0)
          }
      *)
      Definition default (S : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self S in
        match ε, τ, α with
        | [], [], [] =>
          ltac:(M.monadic
            (M.call_closure (|
              M.get_associated_function (|
                Ty.apply (Ty.path "core::hash::sip::Hasher") [] [ S ],
                "new_with_keys",
                []
              |),
              [ Value.Integer IntegerKind.U64 0; Value.Integer IntegerKind.U64 0 ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (S : Ty.t),
        M.IsTraitInstance
          "core::default::Default"
          (Self S)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("default", InstanceField.Method (default S)) ].
    End Impl_core_default_Default_where_core_hash_sip_Sip_S_for_core_hash_sip_Hasher_S.
    
    (* Trait *)
    (* Empty module 'Sip' *)
    
    (* StructTuple
      {
        name := "Sip13Rounds";
        const_params := [];
        ty_params := [];
        fields := [];
      } *)
    
    Module Impl_core_fmt_Debug_for_core_hash_sip_Sip13Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip13Rounds".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        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", "write_str", [] |),
              [ M.read (| f |); M.read (| Value.String "Sip13Rounds" |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_core_hash_sip_Sip13Rounds.
    
    Module Impl_core_clone_Clone_for_core_hash_sip_Sip13Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip13Rounds".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple "core::hash::sip::Sip13Rounds" []))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_core_hash_sip_Sip13Rounds.
    
    Module Impl_core_default_Default_for_core_hash_sip_Sip13Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip13Rounds".
      
      (* Default *)
      Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] => ltac:(M.monadic (Value.StructTuple "core::hash::sip::Sip13Rounds" []))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::default::Default"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("default", InstanceField.Method default) ].
    End Impl_core_default_Default_for_core_hash_sip_Sip13Rounds.
    
    Module Impl_core_hash_sip_Sip_for_core_hash_sip_Sip13Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip13Rounds".
      
      (*
          fn c_rounds(state: &mut State) {
              compress!(state);
          }
      *)
      Definition c_rounds (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ state ] =>
          ltac:(M.monadic
            (let state := M.alloc (| state |) in
            M.read (|
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn d_rounds(state: &mut State) {
              compress!(state);
              compress!(state);
              compress!(state);
          }
      *)
      Definition d_rounds (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ state ] =>
          ltac:(M.monadic
            (let state := M.alloc (| state |) in
            M.read (|
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::sip::Sip"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("c_rounds", InstanceField.Method c_rounds); ("d_rounds", InstanceField.Method d_rounds)
          ].
    End Impl_core_hash_sip_Sip_for_core_hash_sip_Sip13Rounds.
    
    (* StructTuple
      {
        name := "Sip24Rounds";
        const_params := [];
        ty_params := [];
        fields := [];
      } *)
    
    Module Impl_core_fmt_Debug_for_core_hash_sip_Sip24Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip24Rounds".
      
      (* Debug *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        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", "write_str", [] |),
              [ M.read (| f |); M.read (| Value.String "Sip24Rounds" |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Debug"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Debug_for_core_hash_sip_Sip24Rounds.
    
    Module Impl_core_clone_Clone_for_core_hash_sip_Sip24Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip24Rounds".
      
      (* Clone *)
      Definition clone (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.StructTuple "core::hash::sip::Sip24Rounds" []))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::clone::Clone"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("clone", InstanceField.Method clone) ].
    End Impl_core_clone_Clone_for_core_hash_sip_Sip24Rounds.
    
    Module Impl_core_default_Default_for_core_hash_sip_Sip24Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip24Rounds".
      
      (* Default *)
      Definition default (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [] => ltac:(M.monadic (Value.StructTuple "core::hash::sip::Sip24Rounds" []))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::default::Default"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("default", InstanceField.Method default) ].
    End Impl_core_default_Default_for_core_hash_sip_Sip24Rounds.
    
    Module Impl_core_hash_sip_Sip_for_core_hash_sip_Sip24Rounds.
      Definition Self : Ty.t := Ty.path "core::hash::sip::Sip24Rounds".
      
      (*
          fn c_rounds(state: &mut State) {
              compress!(state);
              compress!(state);
          }
      *)
      Definition c_rounds (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ state ] =>
          ltac:(M.monadic
            (let state := M.alloc (| state |) in
            M.read (|
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      (*
          fn d_rounds(state: &mut State) {
              compress!(state);
              compress!(state);
              compress!(state);
              compress!(state);
          }
      *)
      Definition d_rounds (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ state ] =>
          ltac:(M.monadic
            (let state := M.alloc (| state |) in
            M.read (|
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              let~ _ :=
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 13
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 16
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v0"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "wrapping_add", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v0"
                          |)
                        |);
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |)
                      ]
                    |)
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v1"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 17
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v1"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v2"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v3"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 21
                      ]
                    |)
                  |) in
                let~ _ :=
                  let β :=
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v3"
                    |) in
                  M.write (|
                    β,
                    BinOp.bit_xor
                      (M.read (| β |))
                      (M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| state |),
                          "core::hash::sip::State",
                          "v0"
                        |)
                      |))
                  |) in
                let~ _ :=
                  M.write (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| state |),
                      "core::hash::sip::State",
                      "v2"
                    |),
                    M.call_closure (|
                      M.get_associated_function (| Ty.path "u64", "rotate_left", [] |),
                      [
                        M.read (|
                          M.SubPointer.get_struct_record_field (|
                            M.read (| state |),
                            "core::hash::sip::State",
                            "v2"
                          |)
                        |);
                        Value.Integer IntegerKind.U32 32
                      ]
                    |)
                  |) in
                M.alloc (| Value.Tuple [] |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::sip::Sip"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("c_rounds", InstanceField.Method c_rounds); ("d_rounds", InstanceField.Method d_rounds)
          ].
    End Impl_core_hash_sip_Sip_for_core_hash_sip_Sip24Rounds.
  End sip.
End hash.
