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

Module net.
  Module ip_addr.
    (*
    Enum IpAddr
    {
      const_params := [];
      ty_params := [];
      variants :=
        [
          {
            name := "V4";
            item := StructTuple [ Ty.path "core::net::ip_addr::Ipv4Addr" ];
            discriminant := None;
          };
          {
            name := "V6";
            item := StructTuple [ Ty.path "core::net::ip_addr::Ipv6Addr" ];
            discriminant := None;
          }
        ];
    }
    *)
    
    Module Impl_core_marker_Copy_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_clone_Clone_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (* 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.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_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_Eq_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : 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.match_operator (|
                        Value.DeclaredButUndefined,
                        [ fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |))) ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_PartialEq_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (* PartialEq *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.alloc (|
                LogicalOp.and (|
                  BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |),
                  ltac:(M.monadic
                    (M.read (|
                      M.match_operator (|
                        M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "core::net::ip_addr::IpAddr::V4",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "core::net::ip_addr::IpAddr::V4",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "core::net::ip_addr::Ipv4Addr" ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [ __self_0; __arg1_0 ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "core::net::ip_addr::IpAddr::V6",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "core::net::ip_addr::IpAddr::V6",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    Ty.apply
                                      (Ty.path "&")
                                      []
                                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                                    [
                                      Ty.apply
                                        (Ty.path "&")
                                        []
                                        [ Ty.path "core::net::ip_addr::Ipv6Addr" ]
                                    ],
                                    "eq",
                                    []
                                  |),
                                  [ __self_0; __arg1_0 ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.call_closure (|
                                    M.get_function (| "core::intrinsics::unreachable", [] |),
                                    []
                                  |)
                                |)
                              |)))
                        ]
                      |)
                    |)))
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_hash_Hash_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (* Hash *)
      Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __H ], [ self; state ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let state := M.alloc (| state |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::hash::Hash",
                      Ty.path "isize",
                      [],
                      "hash",
                      [ __H ]
                    |),
                    [ __self_discr; M.read (| state |) ]
                  |)
                |) in
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::hash::Hash",
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            [],
                            "hash",
                            [ __H ]
                          |),
                          [ M.read (| __self_0 |); M.read (| state |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::hash::Hash",
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            [],
                            "hash",
                            [ __H ]
                          |),
                          [ M.read (| __self_0 |); M.read (| state |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hash"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("hash", InstanceField.Method hash) ].
    End Impl_core_hash_Hash_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_PartialOrd_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (* PartialOrd *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.match_operator (|
                M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ0_0 := M.read (| γ0_0 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_0,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ2_0 |) in
                      let γ0_1 := M.read (| γ0_1 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_1,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let __arg1_0 := M.alloc (| γ2_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ0_0 := M.read (| γ0_0 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_0,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let __self_0 := M.alloc (| γ2_0 |) in
                      let γ0_1 := M.read (| γ0_1 |) in
                      let γ2_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ0_1,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let __arg1_0 := M.alloc (| γ2_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "isize",
                            [ Ty.path "isize" ],
                            "partial_cmp",
                            []
                          |),
                          [ __self_discr; __arg1_discr ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_Ord_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (* Ord *)
      Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::IpAddr" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.match_operator (|
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::cmp::Ord", Ty.path "isize", [], "cmp", [] |),
                    [ __self_discr; __arg1_discr ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                      M.match_operator (|
                        M.alloc (| Value.Tuple [ M.read (| self |); M.read (| other |) ] |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "core::net::ip_addr::IpAddr::V4",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "core::net::ip_addr::IpAddr::V4",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path "core::net::ip_addr::Ipv4Addr",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                              let γ0_0 := M.read (| γ0_0 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_0,
                                  "core::net::ip_addr::IpAddr::V6",
                                  0
                                |) in
                              let __self_0 := M.alloc (| γ2_0 |) in
                              let γ0_1 := M.read (| γ0_1 |) in
                              let γ2_0 :=
                                M.SubPointer.get_struct_tuple_field (|
                                  γ0_1,
                                  "core::net::ip_addr::IpAddr::V6",
                                  0
                                |) in
                              let __arg1_0 := M.alloc (| γ2_0 |) in
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::Ord",
                                    Ty.path "core::net::ip_addr::Ipv6Addr",
                                    [],
                                    "cmp",
                                    []
                                  |),
                                  [ M.read (| __self_0 |); M.read (| __arg1_0 |) ]
                                |)
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (|
                                M.never_to_any (|
                                  M.call_closure (|
                                    M.get_function (| "core::intrinsics::unreachable", [] |),
                                    []
                                  |)
                                |)
                              |)))
                        ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let cmp := M.copy (| γ |) in
                      cmp))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Ord"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
    End Impl_core_cmp_Ord_for_core_net_ip_addr_IpAddr.
    
    (* StructRecord
      {
        name := "Ipv4Addr";
        const_params := [];
        ty_params := [];
        fields :=
          [
            ("octets",
              Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ Ty.path "u8" ])
          ];
      } *)
    
    Module Impl_core_marker_Copy_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_clone_Clone_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (* 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_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_cmp_PartialEq_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (* PartialEq *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::PartialEq",
                Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ Ty.path "u8" ],
                [ Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ Ty.path "u8" ]
                ],
                "eq",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::net::ip_addr::Ipv4Addr",
                  "octets"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "core::net::ip_addr::Ipv4Addr",
                  "octets"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_cmp_Eq_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : 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.alloc (| Value.Tuple [] |))) ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_hash_Hash_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn hash<H: Hasher>(&self, state: &mut H) {
              // Hashers are often more efficient at hashing a fixed-width integer
              // than a bytestring, so convert before hashing. We don't use to_bits()
              // here as that may involve a byteswap which is unnecessary.
              u32::from_ne_bytes(self.octets).hash(state);
          }
      *)
      Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ H ], [ self; state ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let state := M.alloc (| state |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::hash::Hash", Ty.path "u32", [], "hash", [ H ] |),
                    [
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (| Ty.path "u32", "from_ne_bytes", [] |),
                          [
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "core::net::ip_addr::Ipv4Addr",
                                "octets"
                              |)
                            |)
                          ]
                        |)
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hash"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("hash", InstanceField.Method hash) ].
    End Impl_core_hash_Hash_for_core_net_ip_addr_Ipv4Addr.
    
    (* StructRecord
      {
        name := "Ipv6Addr";
        const_params := [];
        ty_params := [];
        fields :=
          [
            ("octets",
              Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 16 ] [ Ty.path "u8" ])
          ];
      } *)
    
    Module Impl_core_marker_Copy_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_clone_Clone_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (* 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_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_cmp_PartialEq_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (* PartialEq *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::PartialEq",
                Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 16 ] [ Ty.path "u8" ],
                [ Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 16 ] [ Ty.path "u8" ]
                ],
                "eq",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::net::ip_addr::Ipv6Addr",
                  "octets"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "core::net::ip_addr::Ipv6Addr",
                  "octets"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_cmp_Eq_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : 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.alloc (| Value.Tuple [] |))) ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_hash_Hash_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn hash<H: Hasher>(&self, state: &mut H) {
              // Hashers are often more efficient at hashing a fixed-width integer
              // than a bytestring, so convert before hashing. We don't use to_bits()
              // here as that may involve unnecessary byteswaps.
              u128::from_ne_bytes(self.octets).hash(state);
          }
      *)
      Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ H ], [ self; state ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let state := M.alloc (| state |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (| "core::hash::Hash", Ty.path "u128", [], "hash", [ H ] |),
                    [
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (| Ty.path "u128", "from_ne_bytes", [] |),
                          [
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                M.read (| self |),
                                "core::net::ip_addr::Ipv6Addr",
                                "octets"
                              |)
                            |)
                          ]
                        |)
                      |);
                      M.read (| state |)
                    ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hash"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("hash", InstanceField.Method hash) ].
    End Impl_core_hash_Hash_for_core_net_ip_addr_Ipv6Addr.
    
    (*
    Enum Ipv6MulticastScope
    {
      const_params := [];
      ty_params := [];
      variants :=
        [
          {
            name := "InterfaceLocal";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "LinkLocal";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "RealmLocal";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "AdminLocal";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "SiteLocal";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "OrganizationLocal";
            item := StructTuple [];
            discriminant := None;
          };
          {
            name := "Global";
            item := StructTuple [];
            discriminant := None;
          }
        ];
    }
    *)
    
    Module Impl_core_marker_Copy_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::Copy"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_Copy_for_core_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      Axiom Implements :
        M.IsTraitInstance
          "core::marker::StructuralPartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [].
    End Impl_core_marker_StructuralPartialEq_for_core_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_cmp_PartialEq_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      (* PartialEq *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::Ipv6MulticastScope" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              let~ __arg1_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::Ipv6MulticastScope" ]
                    |),
                    [ M.read (| other |) ]
                  |)
                |) in
              M.alloc (| BinOp.eq (| M.read (| __self_discr |), M.read (| __arg1_discr |) |) |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_for_core_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_cmp_Eq_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      (* Eq *)
      Definition assert_receiver_is_total_eq
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            Value.Tuple []))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Eq"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("assert_receiver_is_total_eq", InstanceField.Method assert_receiver_is_total_eq) ].
    End Impl_core_cmp_Eq_for_core_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_clone_Clone_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      (* 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.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_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_hash_Hash_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      (* Hash *)
      Definition hash (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [ __H ], [ self; state ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let state := M.alloc (| state |) in
            M.read (|
              let~ __self_discr :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::discriminant_value",
                      [ Ty.path "core::net::ip_addr::Ipv6MulticastScope" ]
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::hash::Hash", Ty.path "isize", [], "hash", [ __H ] |),
                  [ __self_discr; M.read (| state |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::hash::Hash"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("hash", InstanceField.Method hash) ].
    End Impl_core_hash_Hash_for_core_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_fmt_Debug_for_core_net_ip_addr_Ipv6MulticastScope.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6MulticastScope".
      
      (* 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 (|
                  M.match_operator (|
                    self,
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::InterfaceLocal"
                            |) in
                          M.alloc (| M.read (| Value.String "InterfaceLocal" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::LinkLocal"
                            |) in
                          M.alloc (| M.read (| Value.String "LinkLocal" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::RealmLocal"
                            |) in
                          M.alloc (| M.read (| Value.String "RealmLocal" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::AdminLocal"
                            |) in
                          M.alloc (| M.read (| Value.String "AdminLocal" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::SiteLocal"
                            |) in
                          M.alloc (| M.read (| Value.String "SiteLocal" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::OrganizationLocal"
                            |) in
                          M.alloc (| M.read (| Value.String "OrganizationLocal" |) |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let γ := M.read (| γ |) in
                          let _ :=
                            M.is_struct_tuple (|
                              γ,
                              "core::net::ip_addr::Ipv6MulticastScope::Global"
                            |) in
                          M.alloc (| M.read (| Value.String "Global" |) |)))
                    ]
                  |)
                |)
              ]
            |)))
        | _, _, _ => 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_net_ip_addr_Ipv6MulticastScope.
    
    Module Impl_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          pub const fn is_unspecified(&self) -> bool {
              match self {
                  IpAddr::V4(ip) => ip.is_unspecified(),
                  IpAddr::V6(ip) => ip.is_unspecified(),
              }
          }
      *)
      Definition is_unspecified (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_unspecified",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_unspecified",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unspecified :
        M.IsAssociatedFunction Self "is_unspecified" is_unspecified.
      
      (*
          pub const fn is_loopback(&self) -> bool {
              match self {
                  IpAddr::V4(ip) => ip.is_loopback(),
                  IpAddr::V6(ip) => ip.is_loopback(),
              }
          }
      *)
      Definition is_loopback (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_loopback",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_loopback",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_loopback : M.IsAssociatedFunction Self "is_loopback" is_loopback.
      
      (*
          pub const fn is_global(&self) -> bool {
              match self {
                  IpAddr::V4(ip) => ip.is_global(),
                  IpAddr::V6(ip) => ip.is_global(),
              }
          }
      *)
      Definition is_global (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_global",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_global",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_global : M.IsAssociatedFunction Self "is_global" is_global.
      
      (*
          pub const fn is_multicast(&self) -> bool {
              match self {
                  IpAddr::V4(ip) => ip.is_multicast(),
                  IpAddr::V6(ip) => ip.is_multicast(),
              }
          }
      *)
      Definition is_multicast (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_multicast",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_multicast",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_multicast :
        M.IsAssociatedFunction Self "is_multicast" is_multicast.
      
      (*
          pub const fn is_documentation(&self) -> bool {
              match self {
                  IpAddr::V4(ip) => ip.is_documentation(),
                  IpAddr::V6(ip) => ip.is_documentation(),
              }
          }
      *)
      Definition is_documentation (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_documentation",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_documentation",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_documentation :
        M.IsAssociatedFunction Self "is_documentation" is_documentation.
      
      (*
          pub const fn is_benchmarking(&self) -> bool {
              match self {
                  IpAddr::V4(ip) => ip.is_benchmarking(),
                  IpAddr::V6(ip) => ip.is_benchmarking(),
              }
          }
      *)
      Definition is_benchmarking (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_benchmarking",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_benchmarking",
                            []
                          |),
                          [ M.read (| ip |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_benchmarking :
        M.IsAssociatedFunction Self "is_benchmarking" is_benchmarking.
      
      (*
          pub const fn is_ipv4(&self) -> bool {
              matches!(self, IpAddr::V4(_))
          }
      *)
      Definition is_ipv4 (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_ipv4 : M.IsAssociatedFunction Self "is_ipv4" is_ipv4.
      
      (*
          pub const fn is_ipv6(&self) -> bool {
              matches!(self, IpAddr::V6(_))
          }
      *)
      Definition is_ipv6 (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_ipv6 : M.IsAssociatedFunction Self "is_ipv6" is_ipv6.
      
      (*
          pub const fn to_canonical(&self) -> IpAddr {
              match self {
                  IpAddr::V4(_) => *self,
                  IpAddr::V6(v6) => v6.to_canonical(),
              }
          }
      *)
      Definition to_canonical (ε : 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 (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      M.read (| self |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let v6 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "to_canonical",
                            []
                          |),
                          [ M.read (| v6 |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_canonical :
        M.IsAssociatedFunction Self "to_canonical" to_canonical.
    End Impl_core_net_ip_addr_IpAddr.
    
    Module Impl_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {
              Ipv4Addr { octets: [a, b, c, d] }
          }
      *)
      Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ a; b; c; d ] =>
          ltac:(M.monadic
            (let a := M.alloc (| a |) in
            let b := M.alloc (| b |) in
            let c := M.alloc (| c |) in
            let d := M.alloc (| d |) in
            Value.StructRecord
              "core::net::ip_addr::Ipv4Addr"
              [
                ("octets",
                  Value.Array [ M.read (| a |); M.read (| b |); M.read (| c |); M.read (| d |) ])
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
      
      (*     pub const BITS: u32 = 32; *)
      (* Ty.path "u32" *)
      Definition value_BITS : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U32 32 |))).
      
      Axiom AssociatedConstant_value_BITS : M.IsAssociatedConstant Self "value_BITS" value_BITS.
      
      (*
          pub const fn to_bits(self) -> u32 {
              u32::from_be_bytes(self.octets)
          }
      *)
      Definition to_bits (ε : 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_associated_function (| Ty.path "u32", "from_be_bytes", [] |),
              [
                M.read (|
                  M.SubPointer.get_struct_record_field (|
                    self,
                    "core::net::ip_addr::Ipv4Addr",
                    "octets"
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_bits : M.IsAssociatedFunction Self "to_bits" to_bits.
      
      (*
          pub const fn from_bits(bits: u32) -> Ipv4Addr {
              Ipv4Addr { octets: bits.to_be_bytes() }
          }
      *)
      Definition from_bits (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ bits ] =>
          ltac:(M.monadic
            (let bits := M.alloc (| bits |) in
            Value.StructRecord
              "core::net::ip_addr::Ipv4Addr"
              [
                ("octets",
                  M.call_closure (|
                    M.get_associated_function (| Ty.path "u32", "to_be_bytes", [] |),
                    [ M.read (| bits |) ]
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_from_bits : M.IsAssociatedFunction Self "from_bits" from_bits.
      
      (*     pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1); *)
      (* Ty.path "core::net::ip_addr::Ipv4Addr" *)
      Definition value_LOCALHOST : Value.t :=
        M.run
          ltac:(M.monadic
            (M.alloc (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv4Addr", "new", [] |),
                [
                  Value.Integer IntegerKind.U8 127;
                  Value.Integer IntegerKind.U8 0;
                  Value.Integer IntegerKind.U8 0;
                  Value.Integer IntegerKind.U8 1
                ]
              |)
            |))).
      
      Axiom AssociatedConstant_value_LOCALHOST :
        M.IsAssociatedConstant Self "value_LOCALHOST" value_LOCALHOST.
      
      (*     pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0); *)
      (* Ty.path "core::net::ip_addr::Ipv4Addr" *)
      Definition value_UNSPECIFIED : Value.t :=
        M.run
          ltac:(M.monadic
            (M.alloc (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv4Addr", "new", [] |),
                [
                  Value.Integer IntegerKind.U8 0;
                  Value.Integer IntegerKind.U8 0;
                  Value.Integer IntegerKind.U8 0;
                  Value.Integer IntegerKind.U8 0
                ]
              |)
            |))).
      
      Axiom AssociatedConstant_value_UNSPECIFIED :
        M.IsAssociatedConstant Self "value_UNSPECIFIED" value_UNSPECIFIED.
      
      (*     pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255); *)
      (* Ty.path "core::net::ip_addr::Ipv4Addr" *)
      Definition value_BROADCAST : Value.t :=
        M.run
          ltac:(M.monadic
            (M.alloc (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv4Addr", "new", [] |),
                [
                  Value.Integer IntegerKind.U8 255;
                  Value.Integer IntegerKind.U8 255;
                  Value.Integer IntegerKind.U8 255;
                  Value.Integer IntegerKind.U8 255
                ]
              |)
            |))).
      
      Axiom AssociatedConstant_value_BROADCAST :
        M.IsAssociatedConstant Self "value_BROADCAST" value_BROADCAST.
      
      (*
          pub const fn octets(&self) -> [u8; 4] {
              self.octets
          }
      *)
      Definition octets (ε : 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.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "core::net::ip_addr::Ipv4Addr",
                "octets"
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_octets : M.IsAssociatedFunction Self "octets" octets.
      
      (*
          pub const fn is_unspecified(&self) -> bool {
              u32::from_be_bytes(self.octets) == 0
          }
      *)
      Definition is_unspecified (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "u32", "from_be_bytes", [] |),
                [
                  M.read (|
                    M.SubPointer.get_struct_record_field (|
                      M.read (| self |),
                      "core::net::ip_addr::Ipv4Addr",
                      "octets"
                    |)
                  |)
                ]
              |),
              Value.Integer IntegerKind.U32 0
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unspecified :
        M.IsAssociatedFunction Self "is_unspecified" is_unspecified.
      
      (*
          pub const fn is_loopback(&self) -> bool {
              self.octets()[0] == 127
          }
      *)
      Definition is_loopback (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              M.read (|
                M.SubPointer.get_array_field (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "core::net::ip_addr::Ipv4Addr",
                        "octets",
                        []
                      |),
                      [ M.read (| self |) ]
                    |)
                  |),
                  M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                |)
              |),
              Value.Integer IntegerKind.U8 127
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_loopback : M.IsAssociatedFunction Self "is_loopback" is_loopback.
      
      (*
          pub const fn is_private(&self) -> bool {
              match self.octets() {
                  [10, ..] => true,
                  [172, b, ..] if b >= 16 && b <= 31 => true,
                  [192, 168, ..] => true,
                  _ => false,
              }
          }
      *)
      Definition is_private (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_rest := M.SubPointer.get_slice_rest (| γ, 1, 0 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U8 10
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_rest := M.SubPointer.get_slice_rest (| γ, 2, 0 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U8 172
                        |) in
                      let b := M.copy (| γ0_1 |) in
                      let γ :=
                        M.alloc (|
                          BinOp.ge (| M.read (| b |), Value.Integer IntegerKind.U8 16 |)
                        |) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      let γ :=
                        M.alloc (|
                          BinOp.le (| M.read (| b |), Value.Integer IntegerKind.U8 31 |)
                        |) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_rest := M.SubPointer.get_slice_rest (| γ, 2, 0 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U8 192
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_1 |),
                          Value.Integer IntegerKind.U8 168
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_private : M.IsAssociatedFunction Self "is_private" is_private.
      
      (*
          pub const fn is_link_local(&self) -> bool {
              matches!(self.octets(), [169, 254, ..])
          }
      *)
      Definition is_link_local (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_rest := M.SubPointer.get_slice_rest (| γ, 2, 0 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U8 169
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_1 |),
                          Value.Integer IntegerKind.U8 254
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_link_local :
        M.IsAssociatedFunction Self "is_link_local" is_link_local.
      
      (*
          pub const fn is_global(&self) -> bool {
              !(self.octets()[0] == 0 // "This network"
                  || self.is_private()
                  || self.is_shared()
                  || self.is_loopback()
                  || self.is_link_local()
                  // addresses reserved for future protocols (`192.0.0.0/24`)
                  // .9 and .10 are documented as globally reachable so they're excluded
                  || (
                      self.octets()[0] == 192 && self.octets()[1] == 0 && self.octets()[2] == 0
                      && self.octets()[3] != 9 && self.octets()[3] != 10
                  )
                  || self.is_documentation()
                  || self.is_benchmarking()
                  || self.is_reserved()
                  || self.is_broadcast())
          }
      *)
      Definition is_global (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            UnOp.not (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        LogicalOp.or (|
                          LogicalOp.or (|
                            LogicalOp.or (|
                              LogicalOp.or (|
                                BinOp.eq (|
                                  M.read (|
                                    M.SubPointer.get_array_field (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::net::ip_addr::Ipv4Addr",
                                            "octets",
                                            []
                                          |),
                                          [ M.read (| self |) ]
                                        |)
                                      |),
                                      M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                                    |)
                                  |),
                                  Value.Integer IntegerKind.U8 0
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::net::ip_addr::Ipv4Addr",
                                      "is_private",
                                      []
                                    |),
                                    [ M.read (| self |) ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "core::net::ip_addr::Ipv4Addr",
                                    "is_shared",
                                    []
                                  |),
                                  [ M.read (| self |) ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::net::ip_addr::Ipv4Addr",
                                  "is_loopback",
                                  []
                                |),
                                [ M.read (| self |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "core::net::ip_addr::Ipv4Addr",
                                "is_link_local",
                                []
                              |),
                              [ M.read (| self |) ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (LogicalOp.and (|
                            LogicalOp.and (|
                              LogicalOp.and (|
                                LogicalOp.and (|
                                  BinOp.eq (|
                                    M.read (|
                                      M.SubPointer.get_array_field (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::net::ip_addr::Ipv4Addr",
                                              "octets",
                                              []
                                            |),
                                            [ M.read (| self |) ]
                                          |)
                                        |),
                                        M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                                      |)
                                    |),
                                    Value.Integer IntegerKind.U8 192
                                  |),
                                  ltac:(M.monadic
                                    (BinOp.eq (|
                                      M.read (|
                                        M.SubPointer.get_array_field (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::net::ip_addr::Ipv4Addr",
                                                "octets",
                                                []
                                              |),
                                              [ M.read (| self |) ]
                                            |)
                                          |),
                                          M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                                        |)
                                      |),
                                      Value.Integer IntegerKind.U8 0
                                    |)))
                                |),
                                ltac:(M.monadic
                                  (BinOp.eq (|
                                    M.read (|
                                      M.SubPointer.get_array_field (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::net::ip_addr::Ipv4Addr",
                                              "octets",
                                              []
                                            |),
                                            [ M.read (| self |) ]
                                          |)
                                        |),
                                        M.alloc (| Value.Integer IntegerKind.Usize 2 |)
                                      |)
                                    |),
                                    Value.Integer IntegerKind.U8 0
                                  |)))
                              |),
                              ltac:(M.monadic
                                (BinOp.ne (|
                                  M.read (|
                                    M.SubPointer.get_array_field (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::net::ip_addr::Ipv4Addr",
                                            "octets",
                                            []
                                          |),
                                          [ M.read (| self |) ]
                                        |)
                                      |),
                                      M.alloc (| Value.Integer IntegerKind.Usize 3 |)
                                    |)
                                  |),
                                  Value.Integer IntegerKind.U8 9
                                |)))
                            |),
                            ltac:(M.monadic
                              (BinOp.ne (|
                                M.read (|
                                  M.SubPointer.get_array_field (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::net::ip_addr::Ipv4Addr",
                                          "octets",
                                          []
                                        |),
                                        [ M.read (| self |) ]
                                      |)
                                    |),
                                    M.alloc (| Value.Integer IntegerKind.Usize 3 |)
                                  |)
                                |),
                                Value.Integer IntegerKind.U8 10
                              |)))
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "is_documentation",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv4Addr",
                          "is_benchmarking",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "core::net::ip_addr::Ipv4Addr",
                        "is_reserved",
                        []
                      |),
                      [ M.read (| self |) ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "is_broadcast",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)))
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_global : M.IsAssociatedFunction Self "is_global" is_global.
      
      (*
          pub const fn is_shared(&self) -> bool {
              self.octets()[0] == 100 && (self.octets()[1] & 0b1100_0000 == 0b0100_0000)
          }
      *)
      Definition is_shared (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              BinOp.eq (|
                M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv4Addr",
                          "octets",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |),
                Value.Integer IntegerKind.U8 100
              |),
              ltac:(M.monadic
                (BinOp.eq (|
                  BinOp.bit_and
                    (M.read (|
                      M.SubPointer.get_array_field (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::net::ip_addr::Ipv4Addr",
                              "octets",
                              []
                            |),
                            [ M.read (| self |) ]
                          |)
                        |),
                        M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                      |)
                    |))
                    (Value.Integer IntegerKind.U8 192),
                  Value.Integer IntegerKind.U8 64
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_shared : M.IsAssociatedFunction Self "is_shared" is_shared.
      
      (*
          pub const fn is_benchmarking(&self) -> bool {
              self.octets()[0] == 198 && (self.octets()[1] & 0xfe) == 18
          }
      *)
      Definition is_benchmarking (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              BinOp.eq (|
                M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv4Addr",
                          "octets",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |),
                Value.Integer IntegerKind.U8 198
              |),
              ltac:(M.monadic
                (BinOp.eq (|
                  BinOp.bit_and
                    (M.read (|
                      M.SubPointer.get_array_field (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::net::ip_addr::Ipv4Addr",
                              "octets",
                              []
                            |),
                            [ M.read (| self |) ]
                          |)
                        |),
                        M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                      |)
                    |))
                    (Value.Integer IntegerKind.U8 254),
                  Value.Integer IntegerKind.U8 18
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_benchmarking :
        M.IsAssociatedFunction Self "is_benchmarking" is_benchmarking.
      
      (*
          pub const fn is_reserved(&self) -> bool {
              self.octets()[0] & 240 == 240 && !self.is_broadcast()
          }
      *)
      Definition is_reserved (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              BinOp.eq (|
                BinOp.bit_and
                  (M.read (|
                    M.SubPointer.get_array_field (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "octets",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)
                      |),
                      M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                    |)
                  |))
                  (Value.Integer IntegerKind.U8 240),
                Value.Integer IntegerKind.U8 240
              |),
              ltac:(M.monadic
                (UnOp.not (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "is_broadcast",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_reserved : M.IsAssociatedFunction Self "is_reserved" is_reserved.
      
      (*
          pub const fn is_multicast(&self) -> bool {
              self.octets()[0] >= 224 && self.octets()[0] <= 239
          }
      *)
      Definition is_multicast (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              BinOp.ge (|
                M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv4Addr",
                          "octets",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |),
                Value.Integer IntegerKind.U8 224
              |),
              ltac:(M.monadic
                (BinOp.le (|
                  M.read (|
                    M.SubPointer.get_array_field (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            "octets",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)
                      |),
                      M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                    |)
                  |),
                  Value.Integer IntegerKind.U8 239
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_multicast :
        M.IsAssociatedFunction Self "is_multicast" is_multicast.
      
      (*
          pub const fn is_broadcast(&self) -> bool {
              u32::from_be_bytes(self.octets()) == u32::from_be_bytes(Self::BROADCAST.octets())
          }
      *)
      Definition is_broadcast (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "u32", "from_be_bytes", [] |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                ]
              |),
              M.call_closure (|
                M.get_associated_function (| Ty.path "u32", "from_be_bytes", [] |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.get_constant (| "core::net::ip_addr::BROADCAST" |) ]
                  |)
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_broadcast :
        M.IsAssociatedFunction Self "is_broadcast" is_broadcast.
      
      (*
          pub const fn is_documentation(&self) -> bool {
              matches!(self.octets(), [192, 0, 2, _] | [198, 51, 100, _] | [203, 0, 113, _])
          }
      *)
      Definition is_documentation (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (M.find_or_pattern (|
                        γ,
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                              let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                              let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_0 |),
                                  Value.Integer IntegerKind.U8 192
                                |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_1 |),
                                  Value.Integer IntegerKind.U8 0
                                |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_2 |),
                                  Value.Integer IntegerKind.U8 2
                                |) in
                              Value.Tuple []));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                              let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                              let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_0 |),
                                  Value.Integer IntegerKind.U8 198
                                |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_1 |),
                                  Value.Integer IntegerKind.U8 51
                                |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_2 |),
                                  Value.Integer IntegerKind.U8 100
                                |) in
                              Value.Tuple []));
                          fun γ =>
                            ltac:(M.monadic
                              (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                              let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                              let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                              let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_0 |),
                                  Value.Integer IntegerKind.U8 203
                                |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_1 |),
                                  Value.Integer IntegerKind.U8 0
                                |) in
                              let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ0_2 |),
                                  Value.Integer IntegerKind.U8 113
                                |) in
                              Value.Tuple []))
                        ],
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [] => ltac:(M.monadic (M.alloc (| Value.Bool true |)))
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_documentation :
        M.IsAssociatedFunction Self "is_documentation" is_documentation.
      
      (*
          pub const fn to_ipv6_compatible(&self) -> Ipv6Addr {
              let [a, b, c, d] = self.octets();
              Ipv6Addr { octets: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, a, b, c, d] }
          }
      *)
      Definition to_ipv6_compatible (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let a := M.copy (| γ0_0 |) in
                      let b := M.copy (| γ0_1 |) in
                      let c := M.copy (| γ0_2 |) in
                      let d := M.copy (| γ0_3 |) in
                      M.alloc (|
                        Value.StructRecord
                          "core::net::ip_addr::Ipv6Addr"
                          [
                            ("octets",
                              Value.Array
                                [
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  M.read (| a |);
                                  M.read (| b |);
                                  M.read (| c |);
                                  M.read (| d |)
                                ])
                          ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_ipv6_compatible :
        M.IsAssociatedFunction Self "to_ipv6_compatible" to_ipv6_compatible.
      
      (*
          pub const fn to_ipv6_mapped(&self) -> Ipv6Addr {
              let [a, b, c, d] = self.octets();
              Ipv6Addr { octets: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, a, b, c, d] }
          }
      *)
      Definition to_ipv6_mapped (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let a := M.copy (| γ0_0 |) in
                      let b := M.copy (| γ0_1 |) in
                      let c := M.copy (| γ0_2 |) in
                      let d := M.copy (| γ0_3 |) in
                      M.alloc (|
                        Value.StructRecord
                          "core::net::ip_addr::Ipv6Addr"
                          [
                            ("octets",
                              Value.Array
                                [
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 0;
                                  Value.Integer IntegerKind.U8 255;
                                  Value.Integer IntegerKind.U8 255;
                                  M.read (| a |);
                                  M.read (| b |);
                                  M.read (| c |);
                                  M.read (| d |)
                                ])
                          ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_ipv6_mapped :
        M.IsAssociatedFunction Self "to_ipv6_mapped" to_ipv6_mapped.
    End Impl_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_fmt_Display_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
              match self {
                  IpAddr::V4(ip) => ip.fmt(fmt),
                  IpAddr::V6(ip) => ip.fmt(fmt),
              }
          }
      *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; fmt ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let fmt := M.alloc (| fmt |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::fmt::Display",
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            [],
                            "fmt",
                            []
                          |),
                          [ M.read (| ip |); M.read (| fmt |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let ip := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::fmt::Display",
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            [],
                            "fmt",
                            []
                          |),
                          [ M.read (| ip |); M.read (| fmt |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Display"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Display_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_fmt_Debug_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
              fmt::Display::fmt(self, fmt)
          }
      *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; fmt ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let fmt := M.alloc (| fmt |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::fmt::Display",
                Ty.path "core::net::ip_addr::IpAddr",
                [],
                "fmt",
                []
              |),
              [ M.read (| self |); M.read (| fmt |) ]
            |)))
        | _, _, _ => 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_net_ip_addr_IpAddr.
    
    Module Impl_core_convert_From_core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn from(ipv4: Ipv4Addr) -> IpAddr {
              IpAddr::V4(ipv4)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ ipv4 ] =>
          ltac:(M.monadic
            (let ipv4 := M.alloc (| ipv4 |) in
            Value.StructTuple "core::net::ip_addr::IpAddr::V4" [ M.read (| ipv4 |) ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *) [ (* T *) Ty.path "core::net::ip_addr::Ipv4Addr" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_convert_From_core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn from(ipv6: Ipv6Addr) -> IpAddr {
              IpAddr::V6(ipv6)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ ipv6 ] =>
          ltac:(M.monadic
            (let ipv6 := M.alloc (| ipv6 |) in
            Value.StructTuple "core::net::ip_addr::IpAddr::V6" [ M.read (| ipv6 |) ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *) [ (* T *) Ty.path "core::net::ip_addr::Ipv6Addr" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_fmt_Display_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
              let octets = self.octets();
      
              // If there are no alignment requirements, write the IP address directly to `f`.
              // Otherwise, write it to a local buffer and then use `f.pad`.
              if fmt.precision().is_none() && fmt.width().is_none() {
                  write!(fmt, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3])
              } else {
                  const LONGEST_IPV4_ADDR: &str = "255.255.255.255";
      
                  let mut buf = DisplayBuffer::<{ LONGEST_IPV4_ADDR.len() }>::new();
                  // Buffer is long enough for the longest possible IPv4 address, so this should never fail.
                  write!(buf, "{}.{}.{}.{}", octets[0], octets[1], octets[2], octets[3]).unwrap();
      
                  fmt.pad(buf.as_str())
              }
          }
      *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; fmt ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let fmt := M.alloc (| fmt |) in
            M.read (|
              let~ octets :=
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |) in
              M.match_operator (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.use
                          (M.alloc (|
                            LogicalOp.and (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ],
                                  "is_none",
                                  []
                                |),
                                [
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path "core::fmt::Formatter",
                                        "precision",
                                        []
                                      |),
                                      [ M.read (| fmt |) ]
                                    |)
                                  |)
                                ]
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "usize" ],
                                    "is_none",
                                    []
                                  |),
                                  [
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::Formatter",
                                          "width",
                                          []
                                        |),
                                        [ M.read (| fmt |) ]
                                      |)
                                    |)
                                  ]
                                |)))
                            |)
                          |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::fmt::Formatter",
                            "write_fmt",
                            []
                          |),
                          [
                            M.read (| fmt |);
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "core::fmt::Arguments",
                                "new_v1",
                                []
                              |),
                              [
                                M.alloc (|
                                  Value.Array
                                    [
                                      M.read (| Value.String "" |);
                                      M.read (| Value.String "." |);
                                      M.read (| Value.String "." |);
                                      M.read (| Value.String "." |)
                                    ]
                                |);
                                M.alloc (|
                                  Value.Array
                                    [
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::rt::Argument",
                                          "new_display",
                                          [ Ty.path "u8" ]
                                        |),
                                        [
                                          M.SubPointer.get_array_field (|
                                            octets,
                                            M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                                          |)
                                        ]
                                      |);
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::rt::Argument",
                                          "new_display",
                                          [ Ty.path "u8" ]
                                        |),
                                        [
                                          M.SubPointer.get_array_field (|
                                            octets,
                                            M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                                          |)
                                        ]
                                      |);
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::rt::Argument",
                                          "new_display",
                                          [ Ty.path "u8" ]
                                        |),
                                        [
                                          M.SubPointer.get_array_field (|
                                            octets,
                                            M.alloc (| Value.Integer IntegerKind.Usize 2 |)
                                          |)
                                        ]
                                      |);
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::rt::Argument",
                                          "new_display",
                                          [ Ty.path "u8" ]
                                        |),
                                        [
                                          M.SubPointer.get_array_field (|
                                            octets,
                                            M.alloc (| Value.Integer IntegerKind.Usize 3 |)
                                          |)
                                        ]
                                      |)
                                    ]
                                |)
                              ]
                            |)
                          ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let~ buf :=
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "core::net::display_buffer::DisplayBuffer")
                                [ Value.Integer IntegerKind.Usize 15 ]
                                [],
                              "new",
                              []
                            |),
                            []
                          |)
                        |) in
                      let~ _ :=
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.apply
                                (Ty.path "core::result::Result")
                                []
                                [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                              "unwrap",
                              []
                            |),
                            [
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::fmt::Write",
                                  Ty.apply
                                    (Ty.path "core::net::display_buffer::DisplayBuffer")
                                    [ Value.Integer IntegerKind.Usize 15 ]
                                    [],
                                  [],
                                  "write_fmt",
                                  []
                                |),
                                [
                                  buf;
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::fmt::Arguments",
                                      "new_v1",
                                      []
                                    |),
                                    [
                                      M.alloc (|
                                        Value.Array
                                          [
                                            M.read (| Value.String "" |);
                                            M.read (| Value.String "." |);
                                            M.read (| Value.String "." |);
                                            M.read (| Value.String "." |)
                                          ]
                                      |);
                                      M.alloc (|
                                        Value.Array
                                          [
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::rt::Argument",
                                                "new_display",
                                                [ Ty.path "u8" ]
                                              |),
                                              [
                                                M.SubPointer.get_array_field (|
                                                  octets,
                                                  M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                                                |)
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::rt::Argument",
                                                "new_display",
                                                [ Ty.path "u8" ]
                                              |),
                                              [
                                                M.SubPointer.get_array_field (|
                                                  octets,
                                                  M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                                                |)
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::rt::Argument",
                                                "new_display",
                                                [ Ty.path "u8" ]
                                              |),
                                              [
                                                M.SubPointer.get_array_field (|
                                                  octets,
                                                  M.alloc (| Value.Integer IntegerKind.Usize 2 |)
                                                |)
                                              ]
                                            |);
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::fmt::rt::Argument",
                                                "new_display",
                                                [ Ty.path "u8" ]
                                              |),
                                              [
                                                M.SubPointer.get_array_field (|
                                                  octets,
                                                  M.alloc (| Value.Integer IntegerKind.Usize 3 |)
                                                |)
                                              ]
                                            |)
                                          ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            ]
                          |)
                        |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (| Ty.path "core::fmt::Formatter", "pad", [] |),
                          [
                            M.read (| fmt |);
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.apply
                                  (Ty.path "core::net::display_buffer::DisplayBuffer")
                                  [ Value.Integer IntegerKind.Usize 15 ]
                                  [],
                                "as_str",
                                []
                              |),
                              [ buf ]
                            |)
                          ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Display"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Display_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_fmt_Debug_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
              fmt::Display::fmt(self, fmt)
          }
      *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; fmt ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let fmt := M.alloc (| fmt |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::fmt::Display",
                Ty.path "core::net::ip_addr::Ipv4Addr",
                [],
                "fmt",
                []
              |),
              [ M.read (| self |); M.read (| fmt |) ]
            |)))
        | _, _, _ => 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_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_cmp_PartialEq_core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn eq(&self, other: &Ipv4Addr) -> bool {
              match self {
                  IpAddr::V4(v4) => v4 == other,
                  IpAddr::V6(_) => false,
              }
          }
      *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let v4 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialEq",
                            Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                            [ Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ]
                            ],
                            "eq",
                            []
                          |),
                          [ v4; other ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv4Addr" ]
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_PartialEq_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn eq(&self, other: &IpAddr) -> bool {
              match other {
                  IpAddr::V4(v4) => self == v4,
                  IpAddr::V6(_) => false,
              }
          }
      *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                other,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let v4 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialEq",
                            Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                            [ Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ]
                            ],
                            "eq",
                            []
                          |),
                          [ self; v4 ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::IpAddr" ]
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_cmp_PartialOrd_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
              Some(self.cmp(other))
          }
      *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            Value.StructTuple
              "core::option::Option::Some"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "core::net::ip_addr::Ipv4Addr",
                    [],
                    "cmp",
                    []
                  |),
                  [ M.read (| self |); M.read (| other |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_cmp_PartialOrd_core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {
              match self {
                  IpAddr::V4(v4) => v4.partial_cmp(other),
                  IpAddr::V6(_) => Some(Ordering::Greater),
              }
          }
      *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let v4 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| v4 |); M.read (| other |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv4Addr" ]
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_PartialOrd_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
              match other {
                  IpAddr::V4(v4) => self.partial_cmp(v4),
                  IpAddr::V6(_) => Some(Ordering::Less),
              }
          }
      *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                other,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      let v4 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "core::net::ip_addr::Ipv4Addr",
                            [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| self |); M.read (| v4 |) ]
                        |)
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::IpAddr" ]
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_cmp_Ord_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn cmp(&self, other: &Ipv4Addr) -> Ordering {
              self.octets.cmp(&other.octets)
          }
      *)
      Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::Ord",
                Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ Ty.path "u8" ],
                [],
                "cmp",
                []
              |),
              [
                M.SubPointer.get_struct_record_field (|
                  M.read (| self |),
                  "core::net::ip_addr::Ipv4Addr",
                  "octets"
                |);
                M.SubPointer.get_struct_record_field (|
                  M.read (| other |),
                  "core::net::ip_addr::Ipv4Addr",
                  "octets"
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Ord"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
    End Impl_core_cmp_Ord_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_convert_From_core_net_ip_addr_Ipv4Addr_for_u32.
      Definition Self : Ty.t := Ty.path "u32".
      
      (*
          fn from(ip: Ipv4Addr) -> u32 {
              ip.to_bits()
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ ip ] =>
          ltac:(M.monadic
            (let ip := M.alloc (| ip |) in
            M.call_closure (|
              M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv4Addr", "to_bits", [] |),
              [ M.read (| ip |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *) [ (* T *) Ty.path "core::net::ip_addr::Ipv4Addr" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_core_net_ip_addr_Ipv4Addr_for_u32.
    
    Module Impl_core_convert_From_u32_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn from(ip: u32) -> Ipv4Addr {
              Ipv4Addr::from_bits(ip)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ ip ] =>
          ltac:(M.monadic
            (let ip := M.alloc (| ip |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::net::ip_addr::Ipv4Addr",
                "from_bits",
                []
              |),
              [ M.read (| ip |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *) [ (* T *) Ty.path "u32" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_u32_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_convert_From_array_Usize_4_u8_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn from(octets: [u8; 4]) -> Ipv4Addr {
              Ipv4Addr { octets }
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ octets ] =>
          ltac:(M.monadic
            (let octets := M.alloc (| octets |) in
            Value.StructRecord "core::net::ip_addr::Ipv4Addr" [ ("octets", M.read (| octets |)) ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [
            (* T *)
            Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ Ty.path "u8" ]
          ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_array_Usize_4_u8_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_convert_From_array_Usize_4_u8_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn from(octets: [u8; 4]) -> IpAddr {
              IpAddr::V4(Ipv4Addr::from(octets))
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ octets ] =>
          ltac:(M.monadic
            (let octets := M.alloc (| octets |) in
            Value.StructTuple
              "core::net::ip_addr::IpAddr::V4"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::convert::From",
                    Ty.path "core::net::ip_addr::Ipv4Addr",
                    [
                      Ty.apply
                        (Ty.path "array")
                        [ Value.Integer IntegerKind.Usize 4 ]
                        [ Ty.path "u8" ]
                    ],
                    "from",
                    []
                  |),
                  [ M.read (| octets |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [
            (* T *)
            Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ Ty.path "u8" ]
          ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_array_Usize_4_u8_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr {
              let addr16 = [
                  a.to_be(),
                  b.to_be(),
                  c.to_be(),
                  d.to_be(),
                  e.to_be(),
                  f.to_be(),
                  g.to_be(),
                  h.to_be(),
              ];
              Ipv6Addr {
                  // All elements in `addr16` are big endian.
                  // SAFETY: `[u16; 8]` is always safe to transmute to `[u8; 16]`.
                  octets: unsafe { transmute::<_, [u8; 16]>(addr16) },
              }
          }
      *)
      Definition new (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ a; b; c; d; e; f; g; h ] =>
          ltac:(M.monadic
            (let a := M.alloc (| a |) in
            let b := M.alloc (| b |) in
            let c := M.alloc (| c |) in
            let d := M.alloc (| d |) in
            let e := M.alloc (| e |) in
            let f := M.alloc (| f |) in
            let g := M.alloc (| g |) in
            let h := M.alloc (| h |) in
            M.read (|
              let~ addr16 :=
                M.alloc (|
                  Value.Array
                    [
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| a |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| b |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| c |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| d |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| e |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| f |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| g |) ]
                      |);
                      M.call_closure (|
                        M.get_associated_function (| Ty.path "u16", "to_be", [] |),
                        [ M.read (| h |) ]
                      |)
                    ]
                |) in
              M.alloc (|
                Value.StructRecord
                  "core::net::ip_addr::Ipv6Addr"
                  [
                    ("octets",
                      M.call_closure (|
                        M.get_function (|
                          "core::intrinsics::transmute",
                          [
                            Ty.apply
                              (Ty.path "array")
                              [ Value.Integer IntegerKind.Usize 8 ]
                              [ Ty.path "u16" ];
                            Ty.apply
                              (Ty.path "array")
                              [ Value.Integer IntegerKind.Usize 16 ]
                              [ Ty.path "u8" ]
                          ]
                        |),
                        [ M.read (| addr16 |) ]
                      |))
                  ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_new : M.IsAssociatedFunction Self "new" new.
      
      (*     pub const BITS: u32 = 128; *)
      (* Ty.path "u32" *)
      Definition value_BITS : Value.t :=
        M.run ltac:(M.monadic (M.alloc (| Value.Integer IntegerKind.U32 128 |))).
      
      Axiom AssociatedConstant_value_BITS : M.IsAssociatedConstant Self "value_BITS" value_BITS.
      
      (*
          pub const fn to_bits(self) -> u128 {
              u128::from_be_bytes(self.octets)
          }
      *)
      Definition to_bits (ε : 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_associated_function (| Ty.path "u128", "from_be_bytes", [] |),
              [
                M.read (|
                  M.SubPointer.get_struct_record_field (|
                    self,
                    "core::net::ip_addr::Ipv6Addr",
                    "octets"
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_bits : M.IsAssociatedFunction Self "to_bits" to_bits.
      
      (*
          pub const fn from_bits(bits: u128) -> Ipv6Addr {
              Ipv6Addr { octets: bits.to_be_bytes() }
          }
      *)
      Definition from_bits (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ bits ] =>
          ltac:(M.monadic
            (let bits := M.alloc (| bits |) in
            Value.StructRecord
              "core::net::ip_addr::Ipv6Addr"
              [
                ("octets",
                  M.call_closure (|
                    M.get_associated_function (| Ty.path "u128", "to_be_bytes", [] |),
                    [ M.read (| bits |) ]
                  |))
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_from_bits : M.IsAssociatedFunction Self "from_bits" from_bits.
      
      (*     pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1); *)
      (* Ty.path "core::net::ip_addr::Ipv6Addr" *)
      Definition value_LOCALHOST : Value.t :=
        M.run
          ltac:(M.monadic
            (M.alloc (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv6Addr", "new", [] |),
                [
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 1
                ]
              |)
            |))).
      
      Axiom AssociatedConstant_value_LOCALHOST :
        M.IsAssociatedConstant Self "value_LOCALHOST" value_LOCALHOST.
      
      (*     pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0); *)
      (* Ty.path "core::net::ip_addr::Ipv6Addr" *)
      Definition value_UNSPECIFIED : Value.t :=
        M.run
          ltac:(M.monadic
            (M.alloc (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv6Addr", "new", [] |),
                [
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0;
                  Value.Integer IntegerKind.U16 0
                ]
              |)
            |))).
      
      Axiom AssociatedConstant_value_UNSPECIFIED :
        M.IsAssociatedConstant Self "value_UNSPECIFIED" value_UNSPECIFIED.
      
      (*
          pub const fn segments(&self) -> [u16; 8] {
              // All elements in `self.octets` must be big endian.
              // SAFETY: `[u8; 16]` is always safe to transmute to `[u16; 8]`.
              let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(self.octets) };
              // We want native endian u16
              [
                  u16::from_be(a),
                  u16::from_be(b),
                  u16::from_be(c),
                  u16::from_be(d),
                  u16::from_be(e),
                  u16::from_be(f),
                  u16::from_be(g),
                  u16::from_be(h),
              ]
          }
      *)
      Definition segments (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::transmute",
                      [
                        Ty.apply
                          (Ty.path "array")
                          [ Value.Integer IntegerKind.Usize 16 ]
                          [ Ty.path "u8" ];
                        Ty.apply
                          (Ty.path "array")
                          [ Value.Integer IntegerKind.Usize 8 ]
                          [ Ty.path "u16" ]
                      ]
                    |),
                    [
                      M.read (|
                        M.SubPointer.get_struct_record_field (|
                          M.read (| self |),
                          "core::net::ip_addr::Ipv6Addr",
                          "octets"
                        |)
                      |)
                    ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                      let a := M.copy (| γ0_0 |) in
                      let b := M.copy (| γ0_1 |) in
                      let c := M.copy (| γ0_2 |) in
                      let d := M.copy (| γ0_3 |) in
                      let e := M.copy (| γ0_4 |) in
                      let f := M.copy (| γ0_5 |) in
                      let g := M.copy (| γ0_6 |) in
                      let h := M.copy (| γ0_7 |) in
                      M.alloc (|
                        Value.Array
                          [
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| a |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| b |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| c |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| d |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| e |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| f |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| g |) ]
                            |);
                            M.call_closure (|
                              M.get_associated_function (| Ty.path "u16", "from_be", [] |),
                              [ M.read (| h |) ]
                            |)
                          ]
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_segments : M.IsAssociatedFunction Self "segments" segments.
      
      (*
          pub const fn is_unspecified(&self) -> bool {
              u128::from_be_bytes(self.octets()) == u128::from_be_bytes(Ipv6Addr::UNSPECIFIED.octets())
          }
      *)
      Definition is_unspecified (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "u128", "from_be_bytes", [] |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                ]
              |),
              M.call_closure (|
                M.get_associated_function (| Ty.path "u128", "from_be_bytes", [] |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "octets",
                      []
                    |),
                    [ M.get_constant (| "core::net::ip_addr::UNSPECIFIED" |) ]
                  |)
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unspecified :
        M.IsAssociatedFunction Self "is_unspecified" is_unspecified.
      
      (*
          pub const fn is_loopback(&self) -> bool {
              u128::from_be_bytes(self.octets()) == u128::from_be_bytes(Ipv6Addr::LOCALHOST.octets())
          }
      *)
      Definition is_loopback (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              M.call_closure (|
                M.get_associated_function (| Ty.path "u128", "from_be_bytes", [] |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                ]
              |),
              M.call_closure (|
                M.get_associated_function (| Ty.path "u128", "from_be_bytes", [] |),
                [
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "octets",
                      []
                    |),
                    [ M.get_constant (| "core::net::ip_addr::LOCALHOST" |) ]
                  |)
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_loopback : M.IsAssociatedFunction Self "is_loopback" is_loopback.
      
      (*
          pub const fn is_global(&self) -> bool {
              !(self.is_unspecified()
                  || self.is_loopback()
                  // IPv4-mapped Address (`::ffff:0:0/96`)
                  || matches!(self.segments(), [0, 0, 0, 0, 0, 0xffff, _, _])
                  // IPv4-IPv6 Translat. (`64:ff9b:1::/48`)
                  || matches!(self.segments(), [0x64, 0xff9b, 1, _, _, _, _, _])
                  // Discard-Only Address Block (`100::/64`)
                  || matches!(self.segments(), [0x100, 0, 0, 0, _, _, _, _])
                  // IETF Protocol Assignments (`2001::/23`)
                  || (matches!(self.segments(), [0x2001, b, _, _, _, _, _, _] if b < 0x200)
                      && !(
                          // Port Control Protocol Anycast (`2001:1::1`)
                          u128::from_be_bytes(self.octets()) == 0x2001_0001_0000_0000_0000_0000_0000_0001
                          // Traversal Using Relays around NAT Anycast (`2001:1::2`)
                          || u128::from_be_bytes(self.octets()) == 0x2001_0001_0000_0000_0000_0000_0000_0002
                          // AMT (`2001:3::/32`)
                          || matches!(self.segments(), [0x2001, 3, _, _, _, _, _, _])
                          // AS112-v6 (`2001:4:112::/48`)
                          || matches!(self.segments(), [0x2001, 4, 0x112, _, _, _, _, _])
                          // ORCHIDv2 (`2001:20::/28`)
                          // Drone Remote ID Protocol Entity Tags (DETs) Prefix (`2001:30::/28`)`
                          || matches!(self.segments(), [0x2001, b, _, _, _, _, _, _] if b >= 0x20 && b <= 0x3F)
                      ))
                  // 6to4 (`2002::/16`) – it's not explicitly documented as globally reachable,
                  // IANA says N/A.
                  || matches!(self.segments(), [0x2002, _, _, _, _, _, _, _])
                  || self.is_documentation()
                  || self.is_unique_local()
                  || self.is_unicast_link_local())
          }
      *)
      Definition is_global (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            UnOp.not (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        LogicalOp.or (|
                          LogicalOp.or (|
                            LogicalOp.or (|
                              LogicalOp.or (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "core::net::ip_addr::Ipv6Addr",
                                    "is_unspecified",
                                    []
                                  |),
                                  [ M.read (| self |) ]
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::net::ip_addr::Ipv6Addr",
                                      "is_loopback",
                                      []
                                    |),
                                    [ M.read (| self |) ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.read (|
                                  M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::net::ip_addr::Ipv6Addr",
                                          "segments",
                                          []
                                        |),
                                        [ M.read (| self |) ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                                          let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                          let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                                          let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                                          let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                                          let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                                          let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                                          let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ0_0 |),
                                              Value.Integer IntegerKind.U16 0
                                            |) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ0_1 |),
                                              Value.Integer IntegerKind.U16 0
                                            |) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ0_2 |),
                                              Value.Integer IntegerKind.U16 0
                                            |) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ0_3 |),
                                              Value.Integer IntegerKind.U16 0
                                            |) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ0_4 |),
                                              Value.Integer IntegerKind.U16 0
                                            |) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ0_5 |),
                                              Value.Integer IntegerKind.U16 65535
                                            |) in
                                          M.alloc (| Value.Bool true |)));
                                      fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                    ]
                                  |)
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.read (|
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path "core::net::ip_addr::Ipv6Addr",
                                        "segments",
                                        []
                                      |),
                                      [ M.read (| self |) ]
                                    |)
                                  |),
                                  [
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                                        let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                        let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                                        let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                                        let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                                        let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                                        let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                                        let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                                        let _ :=
                                          M.is_constant_or_break_match (|
                                            M.read (| γ0_0 |),
                                            Value.Integer IntegerKind.U16 100
                                          |) in
                                        let _ :=
                                          M.is_constant_or_break_match (|
                                            M.read (| γ0_1 |),
                                            Value.Integer IntegerKind.U16 65435
                                          |) in
                                        let _ :=
                                          M.is_constant_or_break_match (|
                                            M.read (| γ0_2 |),
                                            Value.Integer IntegerKind.U16 1
                                          |) in
                                        M.alloc (| Value.Bool true |)));
                                    fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                  ]
                                |)
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.read (|
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::net::ip_addr::Ipv6Addr",
                                      "segments",
                                      []
                                    |),
                                    [ M.read (| self |) ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ0_0 |),
                                          Value.Integer IntegerKind.U16 256
                                        |) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ0_1 |),
                                          Value.Integer IntegerKind.U16 0
                                        |) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ0_2 |),
                                          Value.Integer IntegerKind.U16 0
                                        |) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ0_3 |),
                                          Value.Integer IntegerKind.U16 0
                                        |) in
                                      M.alloc (| Value.Bool true |)));
                                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                ]
                              |)
                            |)))
                        |),
                        ltac:(M.monadic
                          (LogicalOp.and (|
                            M.read (|
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::net::ip_addr::Ipv6Addr",
                                      "segments",
                                      []
                                    |),
                                    [ M.read (| self |) ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ0_0 |),
                                          Value.Integer IntegerKind.U16 8193
                                        |) in
                                      let b := M.copy (| γ0_1 |) in
                                      let γ :=
                                        M.alloc (|
                                          BinOp.lt (|
                                            M.read (| b |),
                                            Value.Integer IntegerKind.U16 512
                                          |)
                                        |) in
                                      let _ :=
                                        M.is_constant_or_break_match (|
                                          M.read (| γ |),
                                          Value.Bool true
                                        |) in
                                      M.alloc (| Value.Bool true |)));
                                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                ]
                              |)
                            |),
                            ltac:(M.monadic
                              (UnOp.not (|
                                LogicalOp.or (|
                                  LogicalOp.or (|
                                    LogicalOp.or (|
                                      LogicalOp.or (|
                                        BinOp.eq (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "u128",
                                              "from_be_bytes",
                                              []
                                            |),
                                            [
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path "core::net::ip_addr::Ipv6Addr",
                                                  "octets",
                                                  []
                                                |),
                                                [ M.read (| self |) ]
                                              |)
                                            ]
                                          |),
                                          Value.Integer
                                            IntegerKind.U128
                                            42540488241204005274814694018844196865
                                        |),
                                        ltac:(M.monadic
                                          (BinOp.eq (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "u128",
                                                "from_be_bytes",
                                                []
                                              |),
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::net::ip_addr::Ipv6Addr",
                                                    "octets",
                                                    []
                                                  |),
                                                  [ M.read (| self |) ]
                                                |)
                                              ]
                                            |),
                                            Value.Integer
                                              IntegerKind.U128
                                              42540488241204005274814694018844196866
                                          |)))
                                      |),
                                      ltac:(M.monadic
                                        (M.read (|
                                          M.match_operator (|
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path "core::net::ip_addr::Ipv6Addr",
                                                  "segments",
                                                  []
                                                |),
                                                [ M.read (| self |) ]
                                              |)
                                            |),
                                            [
                                              fun γ =>
                                                ltac:(M.monadic
                                                  (let γ0_0 :=
                                                    M.SubPointer.get_slice_index (| γ, 0 |) in
                                                  let γ0_1 :=
                                                    M.SubPointer.get_slice_index (| γ, 1 |) in
                                                  let γ0_2 :=
                                                    M.SubPointer.get_slice_index (| γ, 2 |) in
                                                  let γ0_3 :=
                                                    M.SubPointer.get_slice_index (| γ, 3 |) in
                                                  let γ0_4 :=
                                                    M.SubPointer.get_slice_index (| γ, 4 |) in
                                                  let γ0_5 :=
                                                    M.SubPointer.get_slice_index (| γ, 5 |) in
                                                  let γ0_6 :=
                                                    M.SubPointer.get_slice_index (| γ, 6 |) in
                                                  let γ0_7 :=
                                                    M.SubPointer.get_slice_index (| γ, 7 |) in
                                                  let _ :=
                                                    M.is_constant_or_break_match (|
                                                      M.read (| γ0_0 |),
                                                      Value.Integer IntegerKind.U16 8193
                                                    |) in
                                                  let _ :=
                                                    M.is_constant_or_break_match (|
                                                      M.read (| γ0_1 |),
                                                      Value.Integer IntegerKind.U16 3
                                                    |) in
                                                  M.alloc (| Value.Bool true |)));
                                              fun γ =>
                                                ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                            ]
                                          |)
                                        |)))
                                    |),
                                    ltac:(M.monadic
                                      (M.read (|
                                        M.match_operator (|
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Ty.path "core::net::ip_addr::Ipv6Addr",
                                                "segments",
                                                []
                                              |),
                                              [ M.read (| self |) ]
                                            |)
                                          |),
                                          [
                                            fun γ =>
                                              ltac:(M.monadic
                                                (let γ0_0 :=
                                                  M.SubPointer.get_slice_index (| γ, 0 |) in
                                                let γ0_1 :=
                                                  M.SubPointer.get_slice_index (| γ, 1 |) in
                                                let γ0_2 :=
                                                  M.SubPointer.get_slice_index (| γ, 2 |) in
                                                let γ0_3 :=
                                                  M.SubPointer.get_slice_index (| γ, 3 |) in
                                                let γ0_4 :=
                                                  M.SubPointer.get_slice_index (| γ, 4 |) in
                                                let γ0_5 :=
                                                  M.SubPointer.get_slice_index (| γ, 5 |) in
                                                let γ0_6 :=
                                                  M.SubPointer.get_slice_index (| γ, 6 |) in
                                                let γ0_7 :=
                                                  M.SubPointer.get_slice_index (| γ, 7 |) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ0_0 |),
                                                    Value.Integer IntegerKind.U16 8193
                                                  |) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ0_1 |),
                                                    Value.Integer IntegerKind.U16 4
                                                  |) in
                                                let _ :=
                                                  M.is_constant_or_break_match (|
                                                    M.read (| γ0_2 |),
                                                    Value.Integer IntegerKind.U16 274
                                                  |) in
                                                M.alloc (| Value.Bool true |)));
                                            fun γ =>
                                              ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                          ]
                                        |)
                                      |)))
                                  |),
                                  ltac:(M.monadic
                                    (M.read (|
                                      M.match_operator (|
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::net::ip_addr::Ipv6Addr",
                                              "segments",
                                              []
                                            |),
                                            [ M.read (| self |) ]
                                          |)
                                        |),
                                        [
                                          fun γ =>
                                            ltac:(M.monadic
                                              (let γ0_0 :=
                                                M.SubPointer.get_slice_index (| γ, 0 |) in
                                              let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                              let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                                              let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                                              let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                                              let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                                              let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                                              let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                                              let _ :=
                                                M.is_constant_or_break_match (|
                                                  M.read (| γ0_0 |),
                                                  Value.Integer IntegerKind.U16 8193
                                                |) in
                                              let b := M.copy (| γ0_1 |) in
                                              let γ :=
                                                M.alloc (|
                                                  BinOp.ge (|
                                                    M.read (| b |),
                                                    Value.Integer IntegerKind.U16 32
                                                  |)
                                                |) in
                                              let _ :=
                                                M.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) in
                                              let γ :=
                                                M.alloc (|
                                                  BinOp.le (|
                                                    M.read (| b |),
                                                    Value.Integer IntegerKind.U16 63
                                                  |)
                                                |) in
                                              let _ :=
                                                M.is_constant_or_break_match (|
                                                  M.read (| γ |),
                                                  Value.Bool true
                                                |) in
                                              M.alloc (| Value.Bool true |)));
                                          fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                                        ]
                                      |)
                                    |)))
                                |)
                              |)))
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.read (|
                          M.match_operator (|
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::net::ip_addr::Ipv6Addr",
                                  "segments",
                                  []
                                |),
                                [ M.read (| self |) ]
                              |)
                            |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                                  let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                  let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                                  let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                                  let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                                  let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                                  let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                                  let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                                  let _ :=
                                    M.is_constant_or_break_match (|
                                      M.read (| γ0_0 |),
                                      Value.Integer IntegerKind.U16 8194
                                    |) in
                                  M.alloc (| Value.Bool true |)));
                              fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                            ]
                          |)
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv6Addr",
                          "is_documentation",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "core::net::ip_addr::Ipv6Addr",
                        "is_unique_local",
                        []
                      |),
                      [ M.read (| self |) ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "is_unicast_link_local",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)))
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_global : M.IsAssociatedFunction Self "is_global" is_global.
      
      (*
          pub const fn is_unique_local(&self) -> bool {
              (self.segments()[0] & 0xfe00) == 0xfc00
          }
      *)
      Definition is_unique_local (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              BinOp.bit_and
                (M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv6Addr",
                          "segments",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |))
                (Value.Integer IntegerKind.U16 65024),
              Value.Integer IntegerKind.U16 64512
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unique_local :
        M.IsAssociatedFunction Self "is_unique_local" is_unique_local.
      
      (*
          pub const fn is_unicast(&self) -> bool {
              !self.is_multicast()
          }
      *)
      Definition is_unicast (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            UnOp.not (|
              M.call_closure (|
                M.get_associated_function (|
                  Ty.path "core::net::ip_addr::Ipv6Addr",
                  "is_multicast",
                  []
                |),
                [ M.read (| self |) ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unicast : M.IsAssociatedFunction Self "is_unicast" is_unicast.
      
      (*
          pub const fn is_unicast_link_local(&self) -> bool {
              (self.segments()[0] & 0xffc0) == 0xfe80
          }
      *)
      Definition is_unicast_link_local (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              BinOp.bit_and
                (M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv6Addr",
                          "segments",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |))
                (Value.Integer IntegerKind.U16 65472),
              Value.Integer IntegerKind.U16 65152
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unicast_link_local :
        M.IsAssociatedFunction Self "is_unicast_link_local" is_unicast_link_local.
      
      (*
          pub const fn is_documentation(&self) -> bool {
              (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)
          }
      *)
      Definition is_documentation (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              BinOp.eq (|
                M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv6Addr",
                          "segments",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |),
                Value.Integer IntegerKind.U16 8193
              |),
              ltac:(M.monadic
                (BinOp.eq (|
                  M.read (|
                    M.SubPointer.get_array_field (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "segments",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)
                      |),
                      M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                    |)
                  |),
                  Value.Integer IntegerKind.U16 3512
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_documentation :
        M.IsAssociatedFunction Self "is_documentation" is_documentation.
      
      (*
          pub const fn is_benchmarking(&self) -> bool {
              (self.segments()[0] == 0x2001) && (self.segments()[1] == 0x2) && (self.segments()[2] == 0)
          }
      *)
      Definition is_benchmarking (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              LogicalOp.and (|
                BinOp.eq (|
                  M.read (|
                    M.SubPointer.get_array_field (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "segments",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)
                      |),
                      M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                    |)
                  |),
                  Value.Integer IntegerKind.U16 8193
                |),
                ltac:(M.monadic
                  (BinOp.eq (|
                    M.read (|
                      M.SubPointer.get_array_field (|
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::net::ip_addr::Ipv6Addr",
                              "segments",
                              []
                            |),
                            [ M.read (| self |) ]
                          |)
                        |),
                        M.alloc (| Value.Integer IntegerKind.Usize 1 |)
                      |)
                    |),
                    Value.Integer IntegerKind.U16 2
                  |)))
              |),
              ltac:(M.monadic
                (BinOp.eq (|
                  M.read (|
                    M.SubPointer.get_array_field (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "segments",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)
                      |),
                      M.alloc (| Value.Integer IntegerKind.Usize 2 |)
                    |)
                  |),
                  Value.Integer IntegerKind.U16 0
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_benchmarking :
        M.IsAssociatedFunction Self "is_benchmarking" is_benchmarking.
      
      (*
          pub const fn is_unicast_global(&self) -> bool {
              self.is_unicast()
                  && !self.is_loopback()
                  && !self.is_unicast_link_local()
                  && !self.is_unique_local()
                  && !self.is_unspecified()
                  && !self.is_documentation()
                  && !self.is_benchmarking()
          }
      *)
      Definition is_unicast_global (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_unicast",
                            []
                          |),
                          [ M.read (| self |) ]
                        |),
                        ltac:(M.monadic
                          (UnOp.not (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "core::net::ip_addr::Ipv6Addr",
                                "is_loopback",
                                []
                              |),
                              [ M.read (| self |) ]
                            |)
                          |)))
                      |),
                      ltac:(M.monadic
                        (UnOp.not (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::net::ip_addr::Ipv6Addr",
                              "is_unicast_link_local",
                              []
                            |),
                            [ M.read (| self |) ]
                          |)
                        |)))
                    |),
                    ltac:(M.monadic
                      (UnOp.not (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "is_unique_local",
                            []
                          |),
                          [ M.read (| self |) ]
                        |)
                      |)))
                  |),
                  ltac:(M.monadic
                    (UnOp.not (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv6Addr",
                          "is_unspecified",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |)))
                |),
                ltac:(M.monadic
                  (UnOp.not (|
                    M.call_closure (|
                      M.get_associated_function (|
                        Ty.path "core::net::ip_addr::Ipv6Addr",
                        "is_documentation",
                        []
                      |),
                      [ M.read (| self |) ]
                    |)
                  |)))
              |),
              ltac:(M.monadic
                (UnOp.not (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "is_benchmarking",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_unicast_global :
        M.IsAssociatedFunction Self "is_unicast_global" is_unicast_global.
      
      (*
          pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {
              if self.is_multicast() {
                  match self.segments()[0] & 0x000f {
                      1 => Some(Ipv6MulticastScope::InterfaceLocal),
                      2 => Some(Ipv6MulticastScope::LinkLocal),
                      3 => Some(Ipv6MulticastScope::RealmLocal),
                      4 => Some(Ipv6MulticastScope::AdminLocal),
                      5 => Some(Ipv6MulticastScope::SiteLocal),
                      8 => Some(Ipv6MulticastScope::OrganizationLocal),
                      14 => Some(Ipv6MulticastScope::Global),
                      _ => None,
                  }
              } else {
                  None
              }
          }
      *)
      Definition multicast_scope (ε : 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 (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.use
                          (M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "core::net::ip_addr::Ipv6Addr",
                                "is_multicast",
                                []
                              |),
                              [ M.read (| self |) ]
                            |)
                          |)) in
                      let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                      M.match_operator (|
                        M.alloc (|
                          BinOp.bit_and
                            (M.read (|
                              M.SubPointer.get_array_field (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.path "core::net::ip_addr::Ipv6Addr",
                                      "segments",
                                      []
                                    |),
                                    [ M.read (| self |) ]
                                  |)
                                |),
                                M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                              |)
                            |))
                            (Value.Integer IntegerKind.U16 15)
                        |),
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 1
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::InterfaceLocal"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 2
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::LinkLocal"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 3
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::RealmLocal"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 4
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::AdminLocal"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 5
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::SiteLocal"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 8
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::OrganizationLocal"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 14
                                |) in
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [
                                    Value.StructTuple
                                      "core::net::ip_addr::Ipv6MulticastScope::Global"
                                      []
                                  ]
                              |)));
                          fun γ =>
                            ltac:(M.monadic
                              (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                        ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_multicast_scope :
        M.IsAssociatedFunction Self "multicast_scope" multicast_scope.
      
      (*
          pub const fn is_multicast(&self) -> bool {
              (self.segments()[0] & 0xff00) == 0xff00
          }
      *)
      Definition is_multicast (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            BinOp.eq (|
              BinOp.bit_and
                (M.read (|
                  M.SubPointer.get_array_field (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.path "core::net::ip_addr::Ipv6Addr",
                          "segments",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |),
                    M.alloc (| Value.Integer IntegerKind.Usize 0 |)
                  |)
                |))
                (Value.Integer IntegerKind.U16 65280),
              Value.Integer IntegerKind.U16 65280
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_multicast :
        M.IsAssociatedFunction Self "is_multicast" is_multicast.
      
      (*
          pub const fn is_ipv4_mapped(&self) -> bool {
              matches!(self.segments(), [0, 0, 0, 0, 0, 0xffff, _, _])
          }
      *)
      Definition is_ipv4_mapped (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "segments",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_1 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_2 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_3 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_4 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_5 |),
                          Value.Integer IntegerKind.U16 65535
                        |) in
                      M.alloc (| Value.Bool true |)));
                  fun γ => ltac:(M.monadic (M.alloc (| Value.Bool false |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_is_ipv4_mapped :
        M.IsAssociatedFunction Self "is_ipv4_mapped" is_ipv4_mapped.
      
      (*
          pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr> {
              match self.octets() {
                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, a, b, c, d] => {
                      Some(Ipv4Addr::new(a, b, c, d))
                  }
                  _ => None,
              }
          }
      *)
      Definition to_ipv4_mapped (ε : 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 (|
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "octets",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                      let γ0_8 := M.SubPointer.get_slice_index (| γ, 8 |) in
                      let γ0_9 := M.SubPointer.get_slice_index (| γ, 9 |) in
                      let γ0_10 := M.SubPointer.get_slice_index (| γ, 10 |) in
                      let γ0_11 := M.SubPointer.get_slice_index (| γ, 11 |) in
                      let γ0_12 := M.SubPointer.get_slice_index (| γ, 12 |) in
                      let γ0_13 := M.SubPointer.get_slice_index (| γ, 13 |) in
                      let γ0_14 := M.SubPointer.get_slice_index (| γ, 14 |) in
                      let γ0_15 := M.SubPointer.get_slice_index (| γ, 15 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_1 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_2 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_3 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_4 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_5 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_6 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_7 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_8 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_9 |),
                          Value.Integer IntegerKind.U8 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_10 |),
                          Value.Integer IntegerKind.U8 255
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_11 |),
                          Value.Integer IntegerKind.U8 255
                        |) in
                      let a := M.copy (| γ0_12 |) in
                      let b := M.copy (| γ0_13 |) in
                      let c := M.copy (| γ0_14 |) in
                      let d := M.copy (| γ0_15 |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "core::net::ip_addr::Ipv4Addr",
                                "new",
                                []
                              |),
                              [ M.read (| a |); M.read (| b |); M.read (| c |); M.read (| d |) ]
                            |)
                          ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_ipv4_mapped :
        M.IsAssociatedFunction Self "to_ipv4_mapped" to_ipv4_mapped.
      
      (*
          pub const fn to_ipv4(&self) -> Option<Ipv4Addr> {
              if let [0, 0, 0, 0, 0, 0 | 0xffff, ab, cd] = self.segments() {
                  let [a, b] = ab.to_be_bytes();
                  let [c, d] = cd.to_be_bytes();
                  Some(Ipv4Addr::new(a, b, c, d))
              } else {
                  None
              }
          }
      *)
      Definition to_ipv4 (ε : 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 (|
                M.alloc (| Value.Tuple [] |),
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ :=
                        M.alloc (|
                          M.call_closure (|
                            M.get_associated_function (|
                              Ty.path "core::net::ip_addr::Ipv6Addr",
                              "segments",
                              []
                            |),
                            [ M.read (| self |) ]
                          |)
                        |) in
                      let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_0 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_1 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_2 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_3 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      let _ :=
                        M.is_constant_or_break_match (|
                          M.read (| γ0_4 |),
                          Value.Integer IntegerKind.U16 0
                        |) in
                      M.find_or_pattern (|
                        γ0_5,
                        [
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 0
                                |) in
                              Value.Tuple []));
                          fun γ =>
                            ltac:(M.monadic
                              (let _ :=
                                M.is_constant_or_break_match (|
                                  M.read (| γ |),
                                  Value.Integer IntegerKind.U16 65535
                                |) in
                              Value.Tuple []))
                        ],
                        M.closure
                          (fun γ =>
                            ltac:(M.monadic
                              match γ with
                              | [] =>
                                ltac:(M.monadic
                                  (let ab := M.copy (| γ0_6 |) in
                                  let cd := M.copy (| γ0_7 |) in
                                  M.match_operator (|
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "u16",
                                          "to_be_bytes",
                                          []
                                        |),
                                        [ M.read (| ab |) ]
                                      |)
                                    |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                                          let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                                          let a := M.copy (| γ0_0 |) in
                                          let b := M.copy (| γ0_1 |) in
                                          M.match_operator (|
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_associated_function (|
                                                  Ty.path "u16",
                                                  "to_be_bytes",
                                                  []
                                                |),
                                                [ M.read (| cd |) ]
                                              |)
                                            |),
                                            [
                                              fun γ =>
                                                ltac:(M.monadic
                                                  (let γ0_0 :=
                                                    M.SubPointer.get_slice_index (| γ, 0 |) in
                                                  let γ0_1 :=
                                                    M.SubPointer.get_slice_index (| γ, 1 |) in
                                                  let c := M.copy (| γ0_0 |) in
                                                  let d := M.copy (| γ0_1 |) in
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        M.call_closure (|
                                                          M.get_associated_function (|
                                                            Ty.path "core::net::ip_addr::Ipv4Addr",
                                                            "new",
                                                            []
                                                          |),
                                                          [
                                                            M.read (| a |);
                                                            M.read (| b |);
                                                            M.read (| c |);
                                                            M.read (| d |)
                                                          ]
                                                        |)
                                                      ]
                                                  |)))
                                            ]
                                          |)))
                                    ]
                                  |)))
                              | _ => M.impossible "wrong number of arguments"
                              end))
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (M.alloc (| Value.StructTuple "core::option::Option::None" [] |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_ipv4 : M.IsAssociatedFunction Self "to_ipv4" to_ipv4.
      
      (*
          pub const fn to_canonical(&self) -> IpAddr {
              if let Some(mapped) = self.to_ipv4_mapped() {
                  return IpAddr::V4(mapped);
              }
              IpAddr::V6( *self)
          }
      *)
      Definition to_canonical (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  let~ _ :=
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.path "core::net::ip_addr::Ipv6Addr",
                                    "to_ipv4_mapped",
                                    []
                                  |),
                                  [ M.read (| self |) ]
                                |)
                              |) in
                            let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let mapped := M.copy (| γ0_0 |) in
                            M.alloc (|
                              M.never_to_any (|
                                M.read (|
                                  M.return_ (|
                                    Value.StructTuple
                                      "core::net::ip_addr::IpAddr::V4"
                                      [ M.read (| mapped |) ]
                                  |)
                                |)
                              |)
                            |)));
                        fun γ => ltac:(M.monadic (M.alloc (| Value.Tuple [] |)))
                      ]
                    |) in
                  M.alloc (|
                    Value.StructTuple
                      "core::net::ip_addr::IpAddr::V6"
                      [ M.read (| M.read (| self |) |) ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_to_canonical :
        M.IsAssociatedFunction Self "to_canonical" to_canonical.
      
      (*
          pub const fn octets(&self) -> [u8; 16] {
              self.octets
          }
      *)
      Definition octets (ε : 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.SubPointer.get_struct_record_field (|
                M.read (| self |),
                "core::net::ip_addr::Ipv6Addr",
                "octets"
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom AssociatedFunction_octets : M.IsAssociatedFunction Self "octets" octets.
    End Impl_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_fmt_Display_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
              // If there are no alignment requirements, write the IP address directly to `f`.
              // Otherwise, write it to a local buffer and then use `f.pad`.
              if f.precision().is_none() && f.width().is_none() {
                  let segments = self.segments();
      
                  if let Some(ipv4) = self.to_ipv4_mapped() {
                      write!(f, "::ffff:{}", ipv4)
                  } else {
                      #[derive(Copy, Clone, Default)]
                      struct Span {
                          start: usize,
                          len: usize,
                      }
      
                      // Find the inner 0 span
                      let zeroes = {
                          let mut longest = Span::default();
                          let mut current = Span::default();
      
                          for (i, &segment) in segments.iter().enumerate() {
                              if segment == 0 {
                                  if current.len == 0 {
                                      current.start = i;
                                  }
      
                                  current.len += 1;
      
                                  if current.len > longest.len {
                                      longest = current;
                                  }
                              } else {
                                  current = Span::default();
                              }
                          }
      
                          longest
                      };
      
                      /// Writes a colon-separated part of the address.
                      #[inline]
                      fn fmt_subslice(f: &mut fmt::Formatter<'_>, chunk: &[u16]) -> fmt::Result {
                          if let Some((first, tail)) = chunk.split_first() {
                              write!(f, "{:x}", first)?;
                              for segment in tail {
                                  f.write_char(':')?;
                                  write!(f, "{:x}", segment)?;
                              }
                          }
                          Ok(())
                      }
      
                      if zeroes.len > 1 {
                          fmt_subslice(f, &segments[..zeroes.start])?;
                          f.write_str("::")?;
                          fmt_subslice(f, &segments[zeroes.start + zeroes.len..])
                      } else {
                          fmt_subslice(f, &segments)
                      }
                  }
              } else {
                  const LONGEST_IPV6_ADDR: &str = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
      
                  let mut buf = DisplayBuffer::<{ LONGEST_IPV6_ADDR.len() }>::new();
                  // Buffer is long enough for the longest possible IPv6 address, so this should never fail.
                  write!(buf, "{}", self).unwrap();
      
                  f.pad(buf.as_str())
              }
          }
      *)
      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.catch_return (|
              ltac:(M.monadic
                (M.read (|
                  M.match_operator (|
                    M.alloc (| Value.Tuple [] |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let γ :=
                            M.use
                              (M.alloc (|
                                LogicalOp.and (|
                                  M.call_closure (|
                                    M.get_associated_function (|
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "usize" ],
                                      "is_none",
                                      []
                                    |),
                                    [
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::fmt::Formatter",
                                            "precision",
                                            []
                                          |),
                                          [ M.read (| f |) ]
                                        |)
                                      |)
                                    ]
                                  |),
                                  ltac:(M.monadic
                                    (M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "usize" ],
                                        "is_none",
                                        []
                                      |),
                                      [
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_associated_function (|
                                              Ty.path "core::fmt::Formatter",
                                              "width",
                                              []
                                            |),
                                            [ M.read (| f |) ]
                                          |)
                                        |)
                                      ]
                                    |)))
                                |)
                              |)) in
                          let _ :=
                            M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                          let~ segments :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.path "core::net::ip_addr::Ipv6Addr",
                                  "segments",
                                  []
                                |),
                                [ M.read (| self |) ]
                              |)
                            |) in
                          M.match_operator (|
                            M.alloc (| Value.Tuple [] |),
                            [
                              fun γ =>
                                ltac:(M.monadic
                                  (let γ :=
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::net::ip_addr::Ipv6Addr",
                                          "to_ipv4_mapped",
                                          []
                                        |),
                                        [ M.read (| self |) ]
                                      |)
                                    |) in
                                  let γ0_0 :=
                                    M.SubPointer.get_struct_tuple_field (|
                                      γ,
                                      "core::option::Option::Some",
                                      0
                                    |) in
                                  let ipv4 := M.copy (| γ0_0 |) in
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_associated_function (|
                                        Ty.path "core::fmt::Formatter",
                                        "write_fmt",
                                        []
                                      |),
                                      [
                                        M.read (| f |);
                                        M.call_closure (|
                                          M.get_associated_function (|
                                            Ty.path "core::fmt::Arguments",
                                            "new_v1",
                                            []
                                          |),
                                          [
                                            M.alloc (|
                                              Value.Array [ M.read (| Value.String "::ffff:" |) ]
                                            |);
                                            M.alloc (|
                                              Value.Array
                                                [
                                                  M.call_closure (|
                                                    M.get_associated_function (|
                                                      Ty.path "core::fmt::rt::Argument",
                                                      "new_display",
                                                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ]
                                                    |),
                                                    [ ipv4 ]
                                                  |)
                                                ]
                                            |)
                                          ]
                                        |)
                                      ]
                                    |)
                                  |)));
                              fun γ =>
                                ltac:(M.monadic
                                  (let~ zeroes :=
                                    M.copy (|
                                      let~ longest :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::default::Default",
                                              Ty.path "core::net::ip_addr::fmt::Span",
                                              [],
                                              "default",
                                              []
                                            |),
                                            []
                                          |)
                                        |) in
                                      let~ current :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::default::Default",
                                              Ty.path "core::net::ip_addr::fmt::Span",
                                              [],
                                              "default",
                                              []
                                            |),
                                            []
                                          |)
                                        |) in
                                      let~ _ :=
                                        M.use
                                          (M.match_operator (|
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::iter::traits::collect::IntoIterator",
                                                  Ty.apply
                                                    (Ty.path
                                                      "core::iter::adapters::enumerate::Enumerate")
                                                    []
                                                    [
                                                      Ty.apply
                                                        (Ty.path "core::slice::iter::Iter")
                                                        []
                                                        [ Ty.path "u16" ]
                                                    ],
                                                  [],
                                                  "into_iter",
                                                  []
                                                |),
                                                [
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::iter::traits::iterator::Iterator",
                                                      Ty.apply
                                                        (Ty.path "core::slice::iter::Iter")
                                                        []
                                                        [ Ty.path "u16" ],
                                                      [],
                                                      "enumerate",
                                                      []
                                                    |),
                                                    [
                                                      M.call_closure (|
                                                        M.get_associated_function (|
                                                          Ty.apply
                                                            (Ty.path "slice")
                                                            []
                                                            [ Ty.path "u16" ],
                                                          "iter",
                                                          []
                                                        |),
                                                        [ segments ]
                                                      |)
                                                    ]
                                                  |)
                                                ]
                                              |)
                                            |),
                                            [
                                              fun γ =>
                                                ltac:(M.monadic
                                                  (let iter := M.copy (| γ |) in
                                                  M.loop (|
                                                    ltac:(M.monadic
                                                      (let~ _ :=
                                                        M.match_operator (|
                                                          M.alloc (|
                                                            M.call_closure (|
                                                              M.get_trait_method (|
                                                                "core::iter::traits::iterator::Iterator",
                                                                Ty.apply
                                                                  (Ty.path
                                                                    "core::iter::adapters::enumerate::Enumerate")
                                                                  []
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::slice::iter::Iter")
                                                                      []
                                                                      [ Ty.path "u16" ]
                                                                  ],
                                                                [],
                                                                "next",
                                                                []
                                                              |),
                                                              [ iter ]
                                                            |)
                                                          |),
                                                          [
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let _ :=
                                                                  M.is_struct_tuple (|
                                                                    γ,
                                                                    "core::option::Option::None"
                                                                  |) in
                                                                M.alloc (|
                                                                  M.never_to_any (|
                                                                    M.read (| M.break (||) |)
                                                                  |)
                                                                |)));
                                                            fun γ =>
                                                              ltac:(M.monadic
                                                                (let γ0_0 :=
                                                                  M.SubPointer.get_struct_tuple_field (|
                                                                    γ,
                                                                    "core::option::Option::Some",
                                                                    0
                                                                  |) in
                                                                let γ1_0 :=
                                                                  M.SubPointer.get_tuple_field (|
                                                                    γ0_0,
                                                                    0
                                                                  |) in
                                                                let γ1_1 :=
                                                                  M.SubPointer.get_tuple_field (|
                                                                    γ0_0,
                                                                    1
                                                                  |) in
                                                                let i := M.copy (| γ1_0 |) in
                                                                let γ1_1 := M.read (| γ1_1 |) in
                                                                let segment := M.copy (| γ1_1 |) in
                                                                M.match_operator (|
                                                                  M.alloc (| Value.Tuple [] |),
                                                                  [
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let γ :=
                                                                          M.use
                                                                            (M.alloc (|
                                                                              BinOp.eq (|
                                                                                M.read (|
                                                                                  segment
                                                                                |),
                                                                                Value.Integer
                                                                                  IntegerKind.U16
                                                                                  0
                                                                              |)
                                                                            |)) 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 (|
                                                                                        BinOp.eq (|
                                                                                          M.read (|
                                                                                            M.SubPointer.get_struct_record_field (|
                                                                                              current,
                                                                                              "core::net::ip_addr::fmt::Span",
                                                                                              "len"
                                                                                            |)
                                                                                          |),
                                                                                          Value.Integer
                                                                                            IntegerKind.Usize
                                                                                            0
                                                                                        |)
                                                                                      |)) in
                                                                                  let _ :=
                                                                                    M.is_constant_or_break_match (|
                                                                                      M.read (|
                                                                                        γ
                                                                                      |),
                                                                                      Value.Bool
                                                                                        true
                                                                                    |) in
                                                                                  let~ _ :=
                                                                                    M.write (|
                                                                                      M.SubPointer.get_struct_record_field (|
                                                                                        current,
                                                                                        "core::net::ip_addr::fmt::Span",
                                                                                        "start"
                                                                                      |),
                                                                                      M.read (| i |)
                                                                                    |) in
                                                                                  M.alloc (|
                                                                                    Value.Tuple []
                                                                                  |)));
                                                                              fun γ =>
                                                                                ltac:(M.monadic
                                                                                  (M.alloc (|
                                                                                    Value.Tuple []
                                                                                  |)))
                                                                            ]
                                                                          |) in
                                                                        let~ _ :=
                                                                          let β :=
                                                                            M.SubPointer.get_struct_record_field (|
                                                                              current,
                                                                              "core::net::ip_addr::fmt::Span",
                                                                              "len"
                                                                            |) in
                                                                          M.write (|
                                                                            β,
                                                                            BinOp.Wrap.add (|
                                                                              M.read (| β |),
                                                                              Value.Integer
                                                                                IntegerKind.Usize
                                                                                1
                                                                            |)
                                                                          |) in
                                                                        M.match_operator (|
                                                                          M.alloc (|
                                                                            Value.Tuple []
                                                                          |),
                                                                          [
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (let γ :=
                                                                                  M.use
                                                                                    (M.alloc (|
                                                                                      BinOp.gt (|
                                                                                        M.read (|
                                                                                          M.SubPointer.get_struct_record_field (|
                                                                                            current,
                                                                                            "core::net::ip_addr::fmt::Span",
                                                                                            "len"
                                                                                          |)
                                                                                        |),
                                                                                        M.read (|
                                                                                          M.SubPointer.get_struct_record_field (|
                                                                                            longest,
                                                                                            "core::net::ip_addr::fmt::Span",
                                                                                            "len"
                                                                                          |)
                                                                                        |)
                                                                                      |)
                                                                                    |)) in
                                                                                let _ :=
                                                                                  M.is_constant_or_break_match (|
                                                                                    M.read (| γ |),
                                                                                    Value.Bool true
                                                                                  |) in
                                                                                let~ _ :=
                                                                                  M.write (|
                                                                                    longest,
                                                                                    M.read (|
                                                                                      current
                                                                                    |)
                                                                                  |) in
                                                                                M.alloc (|
                                                                                  Value.Tuple []
                                                                                |)));
                                                                            fun γ =>
                                                                              ltac:(M.monadic
                                                                                (M.alloc (|
                                                                                  Value.Tuple []
                                                                                |)))
                                                                          ]
                                                                        |)));
                                                                    fun γ =>
                                                                      ltac:(M.monadic
                                                                        (let~ _ :=
                                                                          M.write (|
                                                                            current,
                                                                            M.call_closure (|
                                                                              M.get_trait_method (|
                                                                                "core::default::Default",
                                                                                Ty.path
                                                                                  "core::net::ip_addr::fmt::Span",
                                                                                [],
                                                                                "default",
                                                                                []
                                                                              |),
                                                                              []
                                                                            |)
                                                                          |) in
                                                                        M.alloc (|
                                                                          Value.Tuple []
                                                                        |)))
                                                                  ]
                                                                |)))
                                                          ]
                                                        |) in
                                                      M.alloc (| Value.Tuple [] |)))
                                                  |)))
                                            ]
                                          |)) in
                                      longest
                                    |) in
                                  M.match_operator (|
                                    M.alloc (| Value.Tuple [] |),
                                    [
                                      fun γ =>
                                        ltac:(M.monadic
                                          (let γ :=
                                            M.use
                                              (M.alloc (|
                                                BinOp.gt (|
                                                  M.read (|
                                                    M.SubPointer.get_struct_record_field (|
                                                      zeroes,
                                                      "core::net::ip_addr::fmt::Span",
                                                      "len"
                                                    |)
                                                  |),
                                                  Value.Integer IntegerKind.Usize 1
                                                |)
                                              |)) in
                                          let _ :=
                                            M.is_constant_or_break_match (|
                                              M.read (| γ |),
                                              Value.Bool true
                                            |) in
                                          let~ _ :=
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::ops::try_trait::Try",
                                                    Ty.apply
                                                      (Ty.path "core::result::Result")
                                                      []
                                                      [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                                    [],
                                                    "branch",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Self,
                                                        "fmt_subslice.fmt",
                                                        []
                                                      |),
                                                      [
                                                        M.read (| f |);
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::ops::index::Index",
                                                            Ty.apply
                                                              (Ty.path "array")
                                                              [ Value.Integer IntegerKind.Usize 8 ]
                                                              [ Ty.path "u16" ],
                                                            [
                                                              Ty.apply
                                                                (Ty.path
                                                                  "core::ops::range::RangeTo")
                                                                []
                                                                [ Ty.path "usize" ]
                                                            ],
                                                            "index",
                                                            []
                                                          |),
                                                          [
                                                            segments;
                                                            Value.StructRecord
                                                              "core::ops::range::RangeTo"
                                                              [
                                                                ("end_",
                                                                  M.read (|
                                                                    M.SubPointer.get_struct_record_field (|
                                                                      zeroes,
                                                                      "core::net::ip_addr::fmt::Span",
                                                                      "start"
                                                                    |)
                                                                  |))
                                                              ]
                                                          ]
                                                        |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::ops::control_flow::ControlFlow::Break",
                                                        0
                                                      |) in
                                                    let residual := M.copy (| γ0_0 |) in
                                                    M.alloc (|
                                                      M.never_to_any (|
                                                        M.read (|
                                                          M.return_ (|
                                                            M.call_closure (|
                                                              M.get_trait_method (|
                                                                "core::ops::try_trait::FromResidual",
                                                                Ty.apply
                                                                  (Ty.path "core::result::Result")
                                                                  []
                                                                  [
                                                                    Ty.tuple [];
                                                                    Ty.path "core::fmt::Error"
                                                                  ],
                                                                [
                                                                  Ty.apply
                                                                    (Ty.path "core::result::Result")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "core::convert::Infallible";
                                                                      Ty.path "core::fmt::Error"
                                                                    ]
                                                                ],
                                                                "from_residual",
                                                                []
                                                              |),
                                                              [ M.read (| residual |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::ops::control_flow::ControlFlow::Continue",
                                                        0
                                                      |) in
                                                    let val := M.copy (| γ0_0 |) in
                                                    val))
                                              ]
                                            |) in
                                          let~ _ :=
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::ops::try_trait::Try",
                                                    Ty.apply
                                                      (Ty.path "core::result::Result")
                                                      []
                                                      [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                                    [],
                                                    "branch",
                                                    []
                                                  |),
                                                  [
                                                    M.call_closure (|
                                                      M.get_associated_function (|
                                                        Ty.path "core::fmt::Formatter",
                                                        "write_str",
                                                        []
                                                      |),
                                                      [
                                                        M.read (| f |);
                                                        M.read (| Value.String "::" |)
                                                      ]
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::ops::control_flow::ControlFlow::Break",
                                                        0
                                                      |) in
                                                    let residual := M.copy (| γ0_0 |) in
                                                    M.alloc (|
                                                      M.never_to_any (|
                                                        M.read (|
                                                          M.return_ (|
                                                            M.call_closure (|
                                                              M.get_trait_method (|
                                                                "core::ops::try_trait::FromResidual",
                                                                Ty.apply
                                                                  (Ty.path "core::result::Result")
                                                                  []
                                                                  [
                                                                    Ty.tuple [];
                                                                    Ty.path "core::fmt::Error"
                                                                  ],
                                                                [
                                                                  Ty.apply
                                                                    (Ty.path "core::result::Result")
                                                                    []
                                                                    [
                                                                      Ty.path
                                                                        "core::convert::Infallible";
                                                                      Ty.path "core::fmt::Error"
                                                                    ]
                                                                ],
                                                                "from_residual",
                                                                []
                                                              |),
                                                              [ M.read (| residual |) ]
                                                            |)
                                                          |)
                                                        |)
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::ops::control_flow::ControlFlow::Continue",
                                                        0
                                                      |) in
                                                    let val := M.copy (| γ0_0 |) in
                                                    val))
                                              ]
                                            |) in
                                          M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Self,
                                                "fmt_subslice.fmt",
                                                []
                                              |),
                                              [
                                                M.read (| f |);
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::ops::index::Index",
                                                    Ty.apply
                                                      (Ty.path "array")
                                                      [ Value.Integer IntegerKind.Usize 8 ]
                                                      [ Ty.path "u16" ],
                                                    [
                                                      Ty.apply
                                                        (Ty.path "core::ops::range::RangeFrom")
                                                        []
                                                        [ Ty.path "usize" ]
                                                    ],
                                                    "index",
                                                    []
                                                  |),
                                                  [
                                                    segments;
                                                    Value.StructRecord
                                                      "core::ops::range::RangeFrom"
                                                      [
                                                        ("start",
                                                          BinOp.Wrap.add (|
                                                            M.read (|
                                                              M.SubPointer.get_struct_record_field (|
                                                                zeroes,
                                                                "core::net::ip_addr::fmt::Span",
                                                                "start"
                                                              |)
                                                            |),
                                                            M.read (|
                                                              M.SubPointer.get_struct_record_field (|
                                                                zeroes,
                                                                "core::net::ip_addr::fmt::Span",
                                                                "len"
                                                              |)
                                                            |)
                                                          |))
                                                      ]
                                                  ]
                                                |)
                                              ]
                                            |)
                                          |)));
                                      fun γ =>
                                        ltac:(M.monadic
                                          (M.alloc (|
                                            M.call_closure (|
                                              M.get_associated_function (|
                                                Self,
                                                "fmt_subslice.fmt",
                                                []
                                              |),
                                              [ M.read (| f |); segments ]
                                            |)
                                          |)))
                                    ]
                                  |)))
                            ]
                          |)));
                      fun γ =>
                        ltac:(M.monadic
                          (let~ buf :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "core::net::display_buffer::DisplayBuffer")
                                    [ Value.Integer IntegerKind.Usize 39 ]
                                    [],
                                  "new",
                                  []
                                |),
                                []
                              |)
                            |) in
                          let~ _ :=
                            M.alloc (|
                              M.call_closure (|
                                M.get_associated_function (|
                                  Ty.apply
                                    (Ty.path "core::result::Result")
                                    []
                                    [ Ty.tuple []; Ty.path "core::fmt::Error" ],
                                  "unwrap",
                                  []
                                |),
                                [
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::fmt::Write",
                                      Ty.apply
                                        (Ty.path "core::net::display_buffer::DisplayBuffer")
                                        [ Value.Integer IntegerKind.Usize 39 ]
                                        [],
                                      [],
                                      "write_fmt",
                                      []
                                    |),
                                    [
                                      buf;
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "core::fmt::Arguments",
                                          "new_v1",
                                          []
                                        |),
                                        [
                                          M.alloc (|
                                            Value.Array [ M.read (| Value.String "" |) ]
                                          |);
                                          M.alloc (|
                                            Value.Array
                                              [
                                                M.call_closure (|
                                                  M.get_associated_function (|
                                                    Ty.path "core::fmt::rt::Argument",
                                                    "new_display",
                                                    [
                                                      Ty.apply
                                                        (Ty.path "&")
                                                        []
                                                        [ Ty.path "core::net::ip_addr::Ipv6Addr" ]
                                                    ]
                                                  |),
                                                  [ self ]
                                                |)
                                              ]
                                          |)
                                        ]
                                      |)
                                    ]
                                  |)
                                ]
                              |)
                            |) in
                          M.alloc (|
                            M.call_closure (|
                              M.get_associated_function (|
                                Ty.path "core::fmt::Formatter",
                                "pad",
                                []
                              |),
                              [
                                M.read (| f |);
                                M.call_closure (|
                                  M.get_associated_function (|
                                    Ty.apply
                                      (Ty.path "core::net::display_buffer::DisplayBuffer")
                                      [ Value.Integer IntegerKind.Usize 39 ]
                                      [],
                                    "as_str",
                                    []
                                  |),
                                  [ buf ]
                                |)
                              ]
                            |)
                          |)))
                    ]
                  |)
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::fmt::Display"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("fmt", InstanceField.Method fmt) ].
    End Impl_core_fmt_Display_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_fmt_Debug_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
              fmt::Display::fmt(self, fmt)
          }
      *)
      Definition fmt (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; fmt ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let fmt := M.alloc (| fmt |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::fmt::Display",
                Ty.path "core::net::ip_addr::Ipv6Addr",
                [],
                "fmt",
                []
              |),
              [ M.read (| self |); M.read (| fmt |) ]
            |)))
        | _, _, _ => 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_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_cmp_PartialEq_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn eq(&self, other: &IpAddr) -> bool {
              match other {
                  IpAddr::V4(_) => false,
                  IpAddr::V6(v6) => self == v6,
              }
          }
      *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                other,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      M.alloc (| Value.Bool false |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let v6 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialEq",
                            Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                            [ Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ]
                            ],
                            "eq",
                            []
                          |),
                          [ self; v6 ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::IpAddr" ]
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_cmp_PartialEq_core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn eq(&self, other: &Ipv6Addr) -> bool {
              match self {
                  IpAddr::V4(_) => false,
                  IpAddr::V6(v6) => v6 == other,
              }
          }
      *)
      Definition eq (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      M.alloc (| Value.Bool false |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let v6 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialEq",
                            Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                            [ Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ]
                            ],
                            "eq",
                            []
                          |),
                          [ v6; other ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialEq"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv6Addr" ]
          (* Instance *) [ ("eq", InstanceField.Method eq) ].
    End Impl_core_cmp_PartialEq_core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_PartialOrd_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
              Some(self.cmp(other))
          }
      *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            Value.StructTuple
              "core::option::Option::Some"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::cmp::Ord",
                    Ty.path "core::net::ip_addr::Ipv6Addr",
                    [],
                    "cmp",
                    []
                  |),
                  [ M.read (| self |); M.read (| other |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_cmp_PartialOrd_core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {
              match self {
                  IpAddr::V4(_) => Some(Ordering::Less),
                  IpAddr::V6(v6) => v6.partial_cmp(other),
              }
          }
      *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                self,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let v6 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| v6 |); M.read (| other |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv6Addr" ]
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_cmp_PartialOrd_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {
              match other {
                  IpAddr::V4(_) => Some(Ordering::Greater),
                  IpAddr::V6(v6) => self.partial_cmp(v6),
              }
          }
      *)
      Definition partial_cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.read (|
              M.match_operator (|
                other,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V4",
                          0
                        |) in
                      M.alloc (|
                        Value.StructTuple
                          "core::option::Option::Some"
                          [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                      |)));
                  fun γ =>
                    ltac:(M.monadic
                      (let γ := M.read (| γ |) in
                      let γ1_0 :=
                        M.SubPointer.get_struct_tuple_field (|
                          γ,
                          "core::net::ip_addr::IpAddr::V6",
                          0
                        |) in
                      let v6 := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                            "partial_cmp",
                            []
                          |),
                          [ M.read (| self |); M.read (| v6 |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::PartialOrd"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::IpAddr" ]
          (* Instance *) [ ("partial_cmp", InstanceField.Method partial_cmp) ].
    End Impl_core_cmp_PartialOrd_core_net_ip_addr_IpAddr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_cmp_Ord_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn cmp(&self, other: &Ipv6Addr) -> Ordering {
              self.segments().cmp(&other.segments())
          }
      *)
      Definition cmp (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; other ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let other := M.alloc (| other |) in
            M.call_closure (|
              M.get_trait_method (|
                "core::cmp::Ord",
                Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 8 ] [ Ty.path "u16" ],
                [],
                "cmp",
                []
              |),
              [
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "segments",
                      []
                    |),
                    [ M.read (| self |) ]
                  |)
                |);
                M.alloc (|
                  M.call_closure (|
                    M.get_associated_function (|
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      "segments",
                      []
                    |),
                    [ M.read (| other |) ]
                  |)
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::cmp::Ord"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("cmp", InstanceField.Method cmp) ].
    End Impl_core_cmp_Ord_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_convert_From_core_net_ip_addr_Ipv6Addr_for_u128.
      Definition Self : Ty.t := Ty.path "u128".
      
      (*
          fn from(ip: Ipv6Addr) -> u128 {
              ip.to_bits()
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ ip ] =>
          ltac:(M.monadic
            (let ip := M.alloc (| ip |) in
            M.call_closure (|
              M.get_associated_function (| Ty.path "core::net::ip_addr::Ipv6Addr", "to_bits", [] |),
              [ M.read (| ip |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *) [ (* T *) Ty.path "core::net::ip_addr::Ipv6Addr" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_core_net_ip_addr_Ipv6Addr_for_u128.
    
    Module Impl_core_convert_From_u128_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn from(ip: u128) -> Ipv6Addr {
              Ipv6Addr::from_bits(ip)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ ip ] =>
          ltac:(M.monadic
            (let ip := M.alloc (| ip |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.path "core::net::ip_addr::Ipv6Addr",
                "from_bits",
                []
              |),
              [ M.read (| ip |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *) [ (* T *) Ty.path "u128" ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_u128_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_convert_From_array_Usize_16_u8_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn from(octets: [u8; 16]) -> Ipv6Addr {
              Ipv6Addr { octets }
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ octets ] =>
          ltac:(M.monadic
            (let octets := M.alloc (| octets |) in
            Value.StructRecord "core::net::ip_addr::Ipv6Addr" [ ("octets", M.read (| octets |)) ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [
            (* T *)
            Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 16 ] [ Ty.path "u8" ]
          ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_array_Usize_16_u8_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_convert_From_array_Usize_8_u16_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn from(segments: [u16; 8]) -> Ipv6Addr {
              let [a, b, c, d, e, f, g, h] = segments;
              Ipv6Addr::new(a, b, c, d, e, f, g, h)
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ segments ] =>
          ltac:(M.monadic
            (let segments := M.alloc (| segments |) in
            M.read (|
              M.match_operator (|
                segments,
                [
                  fun γ =>
                    ltac:(M.monadic
                      (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                      let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                      let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                      let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                      let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                      let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                      let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                      let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                      let a := M.copy (| γ0_0 |) in
                      let b := M.copy (| γ0_1 |) in
                      let c := M.copy (| γ0_2 |) in
                      let d := M.copy (| γ0_3 |) in
                      let e := M.copy (| γ0_4 |) in
                      let f := M.copy (| γ0_5 |) in
                      let g := M.copy (| γ0_6 |) in
                      let h := M.copy (| γ0_7 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_associated_function (|
                            Ty.path "core::net::ip_addr::Ipv6Addr",
                            "new",
                            []
                          |),
                          [
                            M.read (| a |);
                            M.read (| b |);
                            M.read (| c |);
                            M.read (| d |);
                            M.read (| e |);
                            M.read (| f |);
                            M.read (| g |);
                            M.read (| h |)
                          ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [
            (* T *)
            Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 8 ] [ Ty.path "u16" ]
          ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_array_Usize_8_u16_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_convert_From_array_Usize_16_u8_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn from(octets: [u8; 16]) -> IpAddr {
              IpAddr::V6(Ipv6Addr::from(octets))
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ octets ] =>
          ltac:(M.monadic
            (let octets := M.alloc (| octets |) in
            Value.StructTuple
              "core::net::ip_addr::IpAddr::V6"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::convert::From",
                    Ty.path "core::net::ip_addr::Ipv6Addr",
                    [
                      Ty.apply
                        (Ty.path "array")
                        [ Value.Integer IntegerKind.Usize 16 ]
                        [ Ty.path "u8" ]
                    ],
                    "from",
                    []
                  |),
                  [ M.read (| octets |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [
            (* T *)
            Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 16 ] [ Ty.path "u8" ]
          ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_array_Usize_16_u8_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_convert_From_array_Usize_8_u16_for_core_net_ip_addr_IpAddr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::IpAddr".
      
      (*
          fn from(segments: [u16; 8]) -> IpAddr {
              IpAddr::V6(Ipv6Addr::from(segments))
          }
      *)
      Definition from (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ segments ] =>
          ltac:(M.monadic
            (let segments := M.alloc (| segments |) in
            Value.StructTuple
              "core::net::ip_addr::IpAddr::V6"
              [
                M.call_closure (|
                  M.get_trait_method (|
                    "core::convert::From",
                    Ty.path "core::net::ip_addr::Ipv6Addr",
                    [
                      Ty.apply
                        (Ty.path "array")
                        [ Value.Integer IntegerKind.Usize 8 ]
                        [ Ty.path "u16" ]
                    ],
                    "from",
                    []
                  |),
                  [ M.read (| segments |) ]
                |)
              ]))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::convert::From"
          Self
          (* Trait polymorphic types *)
          [
            (* T *)
            Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 8 ] [ Ty.path "u16" ]
          ]
          (* Instance *) [ ("from", InstanceField.Method from) ].
    End Impl_core_convert_From_array_Usize_8_u16_for_core_net_ip_addr_IpAddr.
    
    Module Impl_core_ops_bit_Not_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*     type Output = Ipv4Addr; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn not(mut self) -> Ipv4Addr {
              for octet in &mut self.octets {
                  *octet = !*octet;
              }
              self
          }
      *)
      Definition not (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              let~ _ :=
                M.use
                  (M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::collect::IntoIterator",
                          Ty.apply
                            (Ty.path "&mut")
                            []
                            [
                              Ty.apply
                                (Ty.path "array")
                                [ Value.Integer IntegerKind.Usize 4 ]
                                [ Ty.path "u8" ]
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            self,
                            "core::net::ip_addr::Ipv4Addr",
                            "octets"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let iter := M.copy (| γ |) in
                          M.loop (|
                            ltac:(M.monadic
                              (let~ _ :=
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::slice::iter::IterMut")
                                          []
                                          [ Ty.path "u8" ],
                                        [],
                                        "next",
                                        []
                                      |),
                                      [ iter ]
                                    |)
                                  |),
                                  [
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let _ :=
                                          M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                                        M.alloc (|
                                          M.never_to_any (| M.read (| M.break (||) |) |)
                                        |)));
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let γ0_0 :=
                                          M.SubPointer.get_struct_tuple_field (|
                                            γ,
                                            "core::option::Option::Some",
                                            0
                                          |) in
                                        let octet := M.copy (| γ0_0 |) in
                                        let~ _ :=
                                          M.write (|
                                            M.read (| octet |),
                                            UnOp.not (| M.read (| M.read (| octet |) |) |)
                                          |) in
                                        M.alloc (| Value.Tuple [] |)))
                                  ]
                                |) in
                              M.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::Not"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("not", InstanceField.Method not) ].
    End Impl_core_ops_bit_Not_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_Not_for_ref__core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ].
      
      (*     type Output = Ipv4Addr; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
          fn not(self) -> Ipv4Addr {
              !*self
          }
      *)
      Definition not (ε : 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::ops::bit::Not",
                Ty.path "core::net::ip_addr::Ipv4Addr",
                [],
                "not",
                []
              |),
              [ M.read (| M.read (| self |) |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::Not"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("not", InstanceField.Method not) ].
    End Impl_core_ops_bit_Not_for_ref__core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_Not_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*     type Output = Ipv6Addr; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn not(mut self) -> Ipv6Addr {
              for octet in &mut self.octets {
                  *octet = !*octet;
              }
              self
          }
      *)
      Definition not (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.read (|
              let~ _ :=
                M.use
                  (M.match_operator (|
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::iter::traits::collect::IntoIterator",
                          Ty.apply
                            (Ty.path "&mut")
                            []
                            [
                              Ty.apply
                                (Ty.path "array")
                                [ Value.Integer IntegerKind.Usize 16 ]
                                [ Ty.path "u8" ]
                            ],
                          [],
                          "into_iter",
                          []
                        |),
                        [
                          M.SubPointer.get_struct_record_field (|
                            self,
                            "core::net::ip_addr::Ipv6Addr",
                            "octets"
                          |)
                        ]
                      |)
                    |),
                    [
                      fun γ =>
                        ltac:(M.monadic
                          (let iter := M.copy (| γ |) in
                          M.loop (|
                            ltac:(M.monadic
                              (let~ _ :=
                                M.match_operator (|
                                  M.alloc (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "core::iter::traits::iterator::Iterator",
                                        Ty.apply
                                          (Ty.path "core::slice::iter::IterMut")
                                          []
                                          [ Ty.path "u8" ],
                                        [],
                                        "next",
                                        []
                                      |),
                                      [ iter ]
                                    |)
                                  |),
                                  [
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let _ :=
                                          M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                                        M.alloc (|
                                          M.never_to_any (| M.read (| M.break (||) |) |)
                                        |)));
                                    fun γ =>
                                      ltac:(M.monadic
                                        (let γ0_0 :=
                                          M.SubPointer.get_struct_tuple_field (|
                                            γ,
                                            "core::option::Option::Some",
                                            0
                                          |) in
                                        let octet := M.copy (| γ0_0 |) in
                                        let~ _ :=
                                          M.write (|
                                            M.read (| octet |),
                                            UnOp.not (| M.read (| M.read (| octet |) |) |)
                                          |) in
                                        M.alloc (| Value.Tuple [] |)))
                                  ]
                                |) in
                              M.alloc (| Value.Tuple [] |)))
                          |)))
                    ]
                  |)) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::Not"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("not", InstanceField.Method not) ].
    End Impl_core_ops_bit_Not_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_Not_for_ref__core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ].
      
      (*     type Output = Ipv6Addr; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
          fn not(self) -> Ipv6Addr {
              !*self
          }
      *)
      Definition not (ε : 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::ops::bit::Not",
                Ty.path "core::net::ip_addr::Ipv6Addr",
                [],
                "not",
                []
              |),
              [ M.read (| M.read (| self |) |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::Not"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("not", InstanceField.Method not) ].
    End Impl_core_ops_bit_Not_for_ref__core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitAndAssign_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: $ty) {
                          for (lhs, rhs) in iter::zip(&mut self.octets, rhs.octets) {
                              lhs.$bitop_assign(rhs);
                          }
                      }
      *)
      Definition bitand_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              M.use
                (M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::collect::IntoIterator",
                        Ty.apply
                          (Ty.path "core::iter::adapters::zip::Zip")
                          []
                          [
                            Ty.apply (Ty.path "core::slice::iter::IterMut") [] [ Ty.path "u8" ];
                            Ty.apply
                              (Ty.path "core::array::iter::IntoIter")
                              [ Value.Integer IntegerKind.Usize 4 ]
                              [ Ty.path "u8" ]
                          ],
                        [],
                        "into_iter",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_function (|
                            "core::iter::adapters::zip::zip",
                            [
                              Ty.apply
                                (Ty.path "&mut")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "array")
                                    [ Value.Integer IntegerKind.Usize 4 ]
                                    [ Ty.path "u8" ]
                                ];
                              Ty.apply
                                (Ty.path "array")
                                [ Value.Integer IntegerKind.Usize 4 ]
                                [ Ty.path "u8" ]
                            ]
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "core::net::ip_addr::Ipv4Addr",
                              "octets"
                            |);
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                rhs,
                                "core::net::ip_addr::Ipv4Addr",
                                "octets"
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let iter := M.copy (| γ |) in
                        M.loop (|
                          ltac:(M.monadic
                            (let~ _ :=
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "core::iter::adapters::zip::Zip")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "core::slice::iter::IterMut")
                                            []
                                            [ Ty.path "u8" ];
                                          Ty.apply
                                            (Ty.path "core::array::iter::IntoIter")
                                            [ Value.Integer IntegerKind.Usize 4 ]
                                            [ Ty.path "u8" ]
                                        ],
                                      [],
                                      "next",
                                      []
                                    |),
                                    [ iter ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let _ :=
                                        M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::option::Option::Some",
                                          0
                                        |) in
                                      let γ1_0 := M.SubPointer.get_tuple_field (| γ0_0, 0 |) in
                                      let γ1_1 := M.SubPointer.get_tuple_field (| γ0_0, 1 |) in
                                      let lhs := M.copy (| γ1_0 |) in
                                      let rhs := M.copy (| γ1_1 |) in
                                      let~ _ :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::bit::BitAndAssign",
                                              Ty.path "u8",
                                              [ Ty.path "u8" ],
                                              "bitand_assign",
                                              []
                                            |),
                                            [ M.read (| lhs |); M.read (| rhs |) ]
                                          |)
                                        |) in
                                      M.alloc (| Value.Tuple [] |)))
                                ]
                              |) in
                            M.alloc (| Value.Tuple [] |)))
                        |)))
                  ]
                |))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAndAssign"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("bitand_assign", InstanceField.Method bitand_assign) ].
    End Impl_core_ops_bit_BitAndAssign_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitAndAssign_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: &'_ $ty) {
                          self.$bitop_assign( *rhs);
                      }
      *)
      Definition bitand_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ M.read (| self |); M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAndAssign"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ] ]
          (* Instance *) [ ("bitand_assign", InstanceField.Method bitand_assign) ].
    End Impl_core_ops_bit_BitAndAssign_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitAnd_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(mut self, rhs: $ty) -> $ty {
                          self.$bitop_assign(rhs);
                          self
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ self; M.read (| rhs |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(mut self, rhs: &'_ $ty) -> $ty {
                          self.$bitop_assign( *rhs);
                          self
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ self; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitAnd_core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(self, rhs: $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign(rhs);
                          lhs
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ lhs; M.read (| rhs |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv4Addr" ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(self, rhs: &'_ $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign( *rhs);
                          lhs
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ lhs; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitOrAssign_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: $ty) {
                          for (lhs, rhs) in iter::zip(&mut self.octets, rhs.octets) {
                              lhs.$bitop_assign(rhs);
                          }
                      }
      *)
      Definition bitor_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              M.use
                (M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::collect::IntoIterator",
                        Ty.apply
                          (Ty.path "core::iter::adapters::zip::Zip")
                          []
                          [
                            Ty.apply (Ty.path "core::slice::iter::IterMut") [] [ Ty.path "u8" ];
                            Ty.apply
                              (Ty.path "core::array::iter::IntoIter")
                              [ Value.Integer IntegerKind.Usize 4 ]
                              [ Ty.path "u8" ]
                          ],
                        [],
                        "into_iter",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_function (|
                            "core::iter::adapters::zip::zip",
                            [
                              Ty.apply
                                (Ty.path "&mut")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "array")
                                    [ Value.Integer IntegerKind.Usize 4 ]
                                    [ Ty.path "u8" ]
                                ];
                              Ty.apply
                                (Ty.path "array")
                                [ Value.Integer IntegerKind.Usize 4 ]
                                [ Ty.path "u8" ]
                            ]
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "core::net::ip_addr::Ipv4Addr",
                              "octets"
                            |);
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                rhs,
                                "core::net::ip_addr::Ipv4Addr",
                                "octets"
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let iter := M.copy (| γ |) in
                        M.loop (|
                          ltac:(M.monadic
                            (let~ _ :=
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "core::iter::adapters::zip::Zip")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "core::slice::iter::IterMut")
                                            []
                                            [ Ty.path "u8" ];
                                          Ty.apply
                                            (Ty.path "core::array::iter::IntoIter")
                                            [ Value.Integer IntegerKind.Usize 4 ]
                                            [ Ty.path "u8" ]
                                        ],
                                      [],
                                      "next",
                                      []
                                    |),
                                    [ iter ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let _ :=
                                        M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::option::Option::Some",
                                          0
                                        |) in
                                      let γ1_0 := M.SubPointer.get_tuple_field (| γ0_0, 0 |) in
                                      let γ1_1 := M.SubPointer.get_tuple_field (| γ0_0, 1 |) in
                                      let lhs := M.copy (| γ1_0 |) in
                                      let rhs := M.copy (| γ1_1 |) in
                                      let~ _ :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::bit::BitOrAssign",
                                              Ty.path "u8",
                                              [ Ty.path "u8" ],
                                              "bitor_assign",
                                              []
                                            |),
                                            [ M.read (| lhs |); M.read (| rhs |) ]
                                          |)
                                        |) in
                                      M.alloc (| Value.Tuple [] |)))
                                ]
                              |) in
                            M.alloc (| Value.Tuple [] |)))
                        |)))
                  ]
                |))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOrAssign"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("bitor_assign", InstanceField.Method bitor_assign) ].
    End Impl_core_ops_bit_BitOrAssign_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitOrAssign_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: &'_ $ty) {
                          self.$bitop_assign( *rhs);
                      }
      *)
      Definition bitor_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ M.read (| self |); M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOrAssign"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ] ]
          (* Instance *) [ ("bitor_assign", InstanceField.Method bitor_assign) ].
    End Impl_core_ops_bit_BitOrAssign_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitOr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(mut self, rhs: $ty) -> $ty {
                          self.$bitop_assign(rhs);
                          self
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ self; M.read (| rhs |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(mut self, rhs: &'_ $ty) -> $ty {
                          self.$bitop_assign( *rhs);
                          self
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ self; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv4Addr_for_core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitOr_core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(self, rhs: $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign(rhs);
                          lhs
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ lhs; M.read (| rhs |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv4Addr" ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv4Addr".
      
      (*
                      fn $bitop(self, rhs: &'_ $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign( *rhs);
                          lhs
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv4Addr",
                      [ Ty.path "core::net::ip_addr::Ipv4Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ lhs; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv4Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv4Addr_for_ref__core_net_ip_addr_Ipv4Addr.
    
    Module Impl_core_ops_bit_BitAndAssign_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: $ty) {
                          for (lhs, rhs) in iter::zip(&mut self.octets, rhs.octets) {
                              lhs.$bitop_assign(rhs);
                          }
                      }
      *)
      Definition bitand_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              M.use
                (M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::collect::IntoIterator",
                        Ty.apply
                          (Ty.path "core::iter::adapters::zip::Zip")
                          []
                          [
                            Ty.apply (Ty.path "core::slice::iter::IterMut") [] [ Ty.path "u8" ];
                            Ty.apply
                              (Ty.path "core::array::iter::IntoIter")
                              [ Value.Integer IntegerKind.Usize 16 ]
                              [ Ty.path "u8" ]
                          ],
                        [],
                        "into_iter",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_function (|
                            "core::iter::adapters::zip::zip",
                            [
                              Ty.apply
                                (Ty.path "&mut")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "array")
                                    [ Value.Integer IntegerKind.Usize 16 ]
                                    [ Ty.path "u8" ]
                                ];
                              Ty.apply
                                (Ty.path "array")
                                [ Value.Integer IntegerKind.Usize 16 ]
                                [ Ty.path "u8" ]
                            ]
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "core::net::ip_addr::Ipv6Addr",
                              "octets"
                            |);
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                rhs,
                                "core::net::ip_addr::Ipv6Addr",
                                "octets"
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let iter := M.copy (| γ |) in
                        M.loop (|
                          ltac:(M.monadic
                            (let~ _ :=
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "core::iter::adapters::zip::Zip")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "core::slice::iter::IterMut")
                                            []
                                            [ Ty.path "u8" ];
                                          Ty.apply
                                            (Ty.path "core::array::iter::IntoIter")
                                            [ Value.Integer IntegerKind.Usize 16 ]
                                            [ Ty.path "u8" ]
                                        ],
                                      [],
                                      "next",
                                      []
                                    |),
                                    [ iter ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let _ :=
                                        M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::option::Option::Some",
                                          0
                                        |) in
                                      let γ1_0 := M.SubPointer.get_tuple_field (| γ0_0, 0 |) in
                                      let γ1_1 := M.SubPointer.get_tuple_field (| γ0_0, 1 |) in
                                      let lhs := M.copy (| γ1_0 |) in
                                      let rhs := M.copy (| γ1_1 |) in
                                      let~ _ :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::bit::BitAndAssign",
                                              Ty.path "u8",
                                              [ Ty.path "u8" ],
                                              "bitand_assign",
                                              []
                                            |),
                                            [ M.read (| lhs |); M.read (| rhs |) ]
                                          |)
                                        |) in
                                      M.alloc (| Value.Tuple [] |)))
                                ]
                              |) in
                            M.alloc (| Value.Tuple [] |)))
                        |)))
                  ]
                |))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAndAssign"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("bitand_assign", InstanceField.Method bitand_assign) ].
    End Impl_core_ops_bit_BitAndAssign_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitAndAssign_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: &'_ $ty) {
                          self.$bitop_assign( *rhs);
                      }
      *)
      Definition bitand_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ M.read (| self |); M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAndAssign"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ] ]
          (* Instance *) [ ("bitand_assign", InstanceField.Method bitand_assign) ].
    End Impl_core_ops_bit_BitAndAssign_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitAnd_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(mut self, rhs: $ty) -> $ty {
                          self.$bitop_assign(rhs);
                          self
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ self; M.read (| rhs |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(mut self, rhs: &'_ $ty) -> $ty {
                          self.$bitop_assign( *rhs);
                          self
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ self; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitAnd_core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(self, rhs: $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign(rhs);
                          lhs
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ lhs; M.read (| rhs |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv6Addr" ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(self, rhs: &'_ $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign( *rhs);
                          lhs
                      }
      *)
      Definition bitand (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitAndAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitand_assign",
                      []
                    |),
                    [ lhs; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitAnd"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitand", InstanceField.Method bitand) ].
    End Impl_core_ops_bit_BitAnd_ref__core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitOrAssign_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: $ty) {
                          for (lhs, rhs) in iter::zip(&mut self.octets, rhs.octets) {
                              lhs.$bitop_assign(rhs);
                          }
                      }
      *)
      Definition bitor_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              M.use
                (M.match_operator (|
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (|
                        "core::iter::traits::collect::IntoIterator",
                        Ty.apply
                          (Ty.path "core::iter::adapters::zip::Zip")
                          []
                          [
                            Ty.apply (Ty.path "core::slice::iter::IterMut") [] [ Ty.path "u8" ];
                            Ty.apply
                              (Ty.path "core::array::iter::IntoIter")
                              [ Value.Integer IntegerKind.Usize 16 ]
                              [ Ty.path "u8" ]
                          ],
                        [],
                        "into_iter",
                        []
                      |),
                      [
                        M.call_closure (|
                          M.get_function (|
                            "core::iter::adapters::zip::zip",
                            [
                              Ty.apply
                                (Ty.path "&mut")
                                []
                                [
                                  Ty.apply
                                    (Ty.path "array")
                                    [ Value.Integer IntegerKind.Usize 16 ]
                                    [ Ty.path "u8" ]
                                ];
                              Ty.apply
                                (Ty.path "array")
                                [ Value.Integer IntegerKind.Usize 16 ]
                                [ Ty.path "u8" ]
                            ]
                          |),
                          [
                            M.SubPointer.get_struct_record_field (|
                              M.read (| self |),
                              "core::net::ip_addr::Ipv6Addr",
                              "octets"
                            |);
                            M.read (|
                              M.SubPointer.get_struct_record_field (|
                                rhs,
                                "core::net::ip_addr::Ipv6Addr",
                                "octets"
                              |)
                            |)
                          ]
                        |)
                      ]
                    |)
                  |),
                  [
                    fun γ =>
                      ltac:(M.monadic
                        (let iter := M.copy (| γ |) in
                        M.loop (|
                          ltac:(M.monadic
                            (let~ _ :=
                              M.match_operator (|
                                M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::iter::traits::iterator::Iterator",
                                      Ty.apply
                                        (Ty.path "core::iter::adapters::zip::Zip")
                                        []
                                        [
                                          Ty.apply
                                            (Ty.path "core::slice::iter::IterMut")
                                            []
                                            [ Ty.path "u8" ];
                                          Ty.apply
                                            (Ty.path "core::array::iter::IntoIter")
                                            [ Value.Integer IntegerKind.Usize 16 ]
                                            [ Ty.path "u8" ]
                                        ],
                                      [],
                                      "next",
                                      []
                                    |),
                                    [ iter ]
                                  |)
                                |),
                                [
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let _ :=
                                        M.is_struct_tuple (| γ, "core::option::Option::None" |) in
                                      M.alloc (|
                                        M.never_to_any (| M.read (| M.break (||) |) |)
                                      |)));
                                  fun γ =>
                                    ltac:(M.monadic
                                      (let γ0_0 :=
                                        M.SubPointer.get_struct_tuple_field (|
                                          γ,
                                          "core::option::Option::Some",
                                          0
                                        |) in
                                      let γ1_0 := M.SubPointer.get_tuple_field (| γ0_0, 0 |) in
                                      let γ1_1 := M.SubPointer.get_tuple_field (| γ0_0, 1 |) in
                                      let lhs := M.copy (| γ1_0 |) in
                                      let rhs := M.copy (| γ1_1 |) in
                                      let~ _ :=
                                        M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::ops::bit::BitOrAssign",
                                              Ty.path "u8",
                                              [ Ty.path "u8" ],
                                              "bitor_assign",
                                              []
                                            |),
                                            [ M.read (| lhs |); M.read (| rhs |) ]
                                          |)
                                        |) in
                                      M.alloc (| Value.Tuple [] |)))
                                ]
                              |) in
                            M.alloc (| Value.Tuple [] |)))
                        |)))
                  ]
                |))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOrAssign"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("bitor_assign", InstanceField.Method bitor_assign) ].
    End Impl_core_ops_bit_BitOrAssign_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitOrAssign_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop_assign(&mut self, rhs: &'_ $ty) {
                          self.$bitop_assign( *rhs);
                      }
      *)
      Definition bitor_assign (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ M.read (| self |); M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              M.alloc (| Value.Tuple [] |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOrAssign"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ] ]
          (* Instance *) [ ("bitor_assign", InstanceField.Method bitor_assign) ].
    End Impl_core_ops_bit_BitOrAssign_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitOr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(mut self, rhs: $ty) -> $ty {
                          self.$bitop_assign(rhs);
                          self
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ self; M.read (| rhs |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *) []
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(mut self, rhs: &'_ $ty) -> $ty {
                          self.$bitop_assign( *rhs);
                          self
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ self; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              self
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv6Addr_for_core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitOr_core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(self, rhs: $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign(rhs);
                          lhs
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ lhs; M.read (| rhs |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *) [ (* Rhs *) Ty.path "core::net::ip_addr::Ipv6Addr" ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
    
    Module Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
      Definition Self : Ty.t :=
        Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ].
      
      (*                 type Output = $ty; *)
      Definition _Output : Ty.t := Ty.path "core::net::ip_addr::Ipv6Addr".
      
      (*
                      fn $bitop(self, rhs: &'_ $ty) -> $ty {
                          let mut lhs = *self;
                          lhs.$bitop_assign( *rhs);
                          lhs
                      }
      *)
      Definition bitor (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        match ε, τ, α with
        | [], [], [ self; rhs ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            let rhs := M.alloc (| rhs |) in
            M.read (|
              let~ lhs := M.copy (| M.read (| self |) |) in
              let~ _ :=
                M.alloc (|
                  M.call_closure (|
                    M.get_trait_method (|
                      "core::ops::bit::BitOrAssign",
                      Ty.path "core::net::ip_addr::Ipv6Addr",
                      [ Ty.path "core::net::ip_addr::Ipv6Addr" ],
                      "bitor_assign",
                      []
                    |),
                    [ lhs; M.read (| M.read (| rhs |) |) ]
                  |)
                |) in
              lhs
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "core::ops::bit::BitOr"
          Self
          (* Trait polymorphic types *)
          [ (* Rhs *) Ty.apply (Ty.path "&") [] [ Ty.path "core::net::ip_addr::Ipv6Addr" ] ]
          (* Instance *)
          [ ("Output", InstanceField.Ty _Output); ("bitor", InstanceField.Method bitor) ].
    End Impl_core_ops_bit_BitOr_ref__core_net_ip_addr_Ipv6Addr_for_ref__core_net_ip_addr_Ipv6Addr.
  End ip_addr.
End net.
