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

Module vec.
  Module is_zero.
    (* Trait *)
    (* Empty module 'IsZero' *)
    
    Module Impl_alloc_vec_is_zero_IsZero_for_i8.
      Definition Self : Ty.t := Ty.path "i8".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "i8" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "i8" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.I8 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_i8.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_i16.
      Definition Self : Ty.t := Ty.path "i16".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "i16" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "i16" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.I16 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_i16.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_i32.
      Definition Self : Ty.t := Ty.path "i32".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "i32" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "i32" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.I32 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_i32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_i64.
      Definition Self : Ty.t := Ty.path "i64".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "i64" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "i64" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.I64 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_i64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_i128.
      Definition Self : Ty.t := Ty.path "i128".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "i128" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "i128" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (|
                                      M.read (| x |),
                                      Value.Integer IntegerKind.I128 0
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_i128.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_isize.
      Definition Self : Ty.t := Ty.path "isize".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "isize" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "isize" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (|
                                      M.read (| x |),
                                      Value.Integer IntegerKind.Isize 0
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_isize.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_u8.
      Definition Self : Ty.t := Ty.path "u8".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "u8" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "u8" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.U8 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_u8.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_u16.
      Definition Self : Ty.t := Ty.path "u16".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "u16" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "u16" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.U16 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_u16.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_u32.
      Definition Self : Ty.t := Ty.path "u32".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "u32" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "u32" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.U32 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_u32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_u64.
      Definition Self : Ty.t := Ty.path "u64".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "u64" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "u64" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Integer IntegerKind.U64 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_u64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_u128.
      Definition Self : Ty.t := Ty.path "u128".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "u128" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "u128" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (|
                                      M.read (| x |),
                                      Value.Integer IntegerKind.U128 0
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_u128.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_usize.
      Definition Self : Ty.t := Ty.path "usize".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "usize" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "usize" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (|
                                      M.read (| x |),
                                      Value.Integer IntegerKind.Usize 0
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_usize.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_bool.
      Definition Self : Ty.t := Ty.path "bool".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "bool" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "bool" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.Bool false |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_bool.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_char.
      Definition Self : Ty.t := Ty.path "char".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "char" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "char" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (| M.read (| x |), Value.UnicodeChar 0 |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_char.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_f32.
      Definition Self : Ty.t := Ty.path "f32".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "f32" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "f32" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "f32",
                                          "to_bits",
                                          []
                                        |),
                                        [ M.read (| x |) ]
                                      |),
                                      Value.Integer IntegerKind.U32 0
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_f32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_f64.
      Definition Self : Ty.t := Ty.path "f64".
      
      (*
                  fn is_zero(&self) -> bool {
                      $is_zero( *self)
                  }
      *)
      Definition is_zero (ε : 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::function::Fn",
                Ty.function [ Ty.tuple [ Ty.path "f64" ] ] (Ty.path "bool"),
                [ Ty.tuple [ Ty.path "f64" ] ],
                "call",
                []
              |),
              [
                M.alloc (|
                  M.closure
                    (fun γ =>
                      ltac:(M.monadic
                        match γ with
                        | [ α0 ] =>
                          ltac:(M.monadic
                            (M.match_operator (|
                              M.alloc (| α0 |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let x := M.copy (| γ |) in
                                    BinOp.eq (|
                                      M.call_closure (|
                                        M.get_associated_function (|
                                          Ty.path "f64",
                                          "to_bits",
                                          []
                                        |),
                                        [ M.read (| x |) ]
                                      |),
                                      Value.Integer IntegerKind.U64 0
                                    |)))
                              ]
                            |)))
                        | _ => M.impossible "wrong number of arguments"
                        end))
                |);
                Value.Tuple [ M.read (| M.read (| self |) |) ]
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_f64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_pointer_const_T.
      Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "*const") [] [ T ].
      
      (*
          fn is_zero(&self) -> bool {
              ( *self).is_null()
          }
      *)
      Definition is_zero (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (| Ty.apply (Ty.path "*const") [] [ T ], "is_null", [] |),
              [ M.read (| M.read (| self |) |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero T)) ].
    End Impl_alloc_vec_is_zero_IsZero_for_pointer_const_T.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_pointer_mut_T.
      Definition Self (T : Ty.t) : Ty.t := Ty.apply (Ty.path "*mut") [] [ T ].
      
      (*
          fn is_zero(&self) -> bool {
              ( *self).is_null()
          }
      *)
      Definition is_zero (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (| Ty.apply (Ty.path "*mut") [] [ T ], "is_null", [] |),
              [ M.read (| M.read (| self |) |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero T)) ].
    End Impl_alloc_vec_is_zero_IsZero_for_pointer_mut_T.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_T_for_array_N_T.
      Definition Self (N : Value.t) (T : Ty.t) : Ty.t := Ty.apply (Ty.path "array") [ N ] [ T ].
      
      (*
          fn is_zero(&self) -> bool {
              // Because this is generated as a runtime check, it's not obvious that
              // it's worth doing if the array is really long. The threshold here
              // is largely arbitrary, but was picked because as of 2022-07-01 LLVM
              // fails to const-fold the check in `vec![[1; 32]; n]`
              // See https://github.com/rust-lang/rust/pull/97581#issuecomment-1166628022
              // Feel free to tweak if you have better evidence.
      
              N <= 16 && self.iter().all(IsZero::is_zero)
          }
      *)
      Definition is_zero
          (N : Value.t)
          (T : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self N T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            LogicalOp.and (|
              BinOp.le (|
                M.read (| M.get_constant (| "alloc::vec::is_zero::N" |) |),
                Value.Integer IntegerKind.Usize 16
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (|
                    "core::iter::traits::iterator::Iterator",
                    Ty.apply (Ty.path "core::slice::iter::Iter") [] [ T ],
                    [],
                    "all",
                    [ Ty.function [ Ty.apply (Ty.path "&") [] [ T ] ] (Ty.path "bool") ]
                  |),
                  [
                    M.alloc (|
                      M.call_closure (|
                        M.get_associated_function (|
                          Ty.apply (Ty.path "slice") [] [ T ],
                          "iter",
                          []
                        |),
                        [ M.read (| self |) ]
                      |)
                    |);
                    M.get_trait_method (| "alloc::vec::is_zero::IsZero", T, [], "is_zero", [] |)
                  ]
                |)))
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (N : Value.t) (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self N T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero N T)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_T_for_array_N_T.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_A_where_alloc_vec_is_zero_IsZero_B_where_alloc_vec_is_zero_IsZero_C_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_A_B_C_D_E_F_G_H_.
      Definition Self (A B C D E F G H : Ty.t) : Ty.t := Ty.tuple [ A; B; C; D; E; F; G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero
          (A B C D E F G H : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self A B C D E F G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ1_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                      let γ1_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                      let γ1_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                      let γ1_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                      let γ1_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                      let γ1_7 := M.SubPointer.get_tuple_field (| γ, 7 |) in
                      let value_A := M.alloc (| γ1_0 |) in
                      let value_B := M.alloc (| γ1_1 |) in
                      let value_C := M.alloc (| γ1_2 |) in
                      let value_D := M.alloc (| γ1_3 |) in
                      let value_E := M.alloc (| γ1_4 |) in
                      let value_F := M.alloc (| γ1_5 |) in
                      let value_G := M.alloc (| γ1_6 |) in
                      let value_H := M.alloc (| γ1_7 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              LogicalOp.and (|
                                LogicalOp.and (|
                                  LogicalOp.and (|
                                    LogicalOp.and (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "alloc::vec::is_zero::IsZero",
                                          A,
                                          [],
                                          "is_zero",
                                          []
                                        |),
                                        [ M.read (| value_A |) ]
                                      |),
                                      ltac:(M.monadic
                                        (M.call_closure (|
                                          M.get_trait_method (|
                                            "alloc::vec::is_zero::IsZero",
                                            B,
                                            [],
                                            "is_zero",
                                            []
                                          |),
                                          [ M.read (| value_B |) ]
                                        |)))
                                    |),
                                    ltac:(M.monadic
                                      (M.call_closure (|
                                        M.get_trait_method (|
                                          "alloc::vec::is_zero::IsZero",
                                          C,
                                          [],
                                          "is_zero",
                                          []
                                        |),
                                        [ M.read (| value_C |) ]
                                      |)))
                                  |),
                                  ltac:(M.monadic
                                    (M.call_closure (|
                                      M.get_trait_method (|
                                        "alloc::vec::is_zero::IsZero",
                                        D,
                                        [],
                                        "is_zero",
                                        []
                                      |),
                                      [ M.read (| value_D |) ]
                                    |)))
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "alloc::vec::is_zero::IsZero",
                                      E,
                                      [],
                                      "is_zero",
                                      []
                                    |),
                                    [ M.read (| value_E |) ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "alloc::vec::is_zero::IsZero",
                                    F,
                                    [],
                                    "is_zero",
                                    []
                                  |),
                                  [ M.read (| value_F |) ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  G,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_G |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (A B C D E F G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self A B C D E F G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero A B C D E F G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_A_where_alloc_vec_is_zero_IsZero_B_where_alloc_vec_is_zero_IsZero_C_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_A_B_C_D_E_F_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_B_where_alloc_vec_is_zero_IsZero_C_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_B_C_D_E_F_G_H_.
      Definition Self (B C D E F G H : Ty.t) : Ty.t := Ty.tuple [ B; C; D; E; F; G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero
          (B C D E F G H : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self B C D E F G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ1_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                      let γ1_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                      let γ1_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                      let γ1_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                      let γ1_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                      let value_B := M.alloc (| γ1_0 |) in
                      let value_C := M.alloc (| γ1_1 |) in
                      let value_D := M.alloc (| γ1_2 |) in
                      let value_E := M.alloc (| γ1_3 |) in
                      let value_F := M.alloc (| γ1_4 |) in
                      let value_G := M.alloc (| γ1_5 |) in
                      let value_H := M.alloc (| γ1_6 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              LogicalOp.and (|
                                LogicalOp.and (|
                                  LogicalOp.and (|
                                    M.call_closure (|
                                      M.get_trait_method (|
                                        "alloc::vec::is_zero::IsZero",
                                        B,
                                        [],
                                        "is_zero",
                                        []
                                      |),
                                      [ M.read (| value_B |) ]
                                    |),
                                    ltac:(M.monadic
                                      (M.call_closure (|
                                        M.get_trait_method (|
                                          "alloc::vec::is_zero::IsZero",
                                          C,
                                          [],
                                          "is_zero",
                                          []
                                        |),
                                        [ M.read (| value_C |) ]
                                      |)))
                                  |),
                                  ltac:(M.monadic
                                    (M.call_closure (|
                                      M.get_trait_method (|
                                        "alloc::vec::is_zero::IsZero",
                                        D,
                                        [],
                                        "is_zero",
                                        []
                                      |),
                                      [ M.read (| value_D |) ]
                                    |)))
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "alloc::vec::is_zero::IsZero",
                                      E,
                                      [],
                                      "is_zero",
                                      []
                                    |),
                                    [ M.read (| value_E |) ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "alloc::vec::is_zero::IsZero",
                                    F,
                                    [],
                                    "is_zero",
                                    []
                                  |),
                                  [ M.read (| value_F |) ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  G,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_G |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (B C D E F G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self B C D E F G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero B C D E F G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_B_where_alloc_vec_is_zero_IsZero_C_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_B_C_D_E_F_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_C_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_C_D_E_F_G_H_.
      Definition Self (C D E F G H : Ty.t) : Ty.t := Ty.tuple [ C; D; E; F; G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero
          (C D E F G H : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self C D E F G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ1_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                      let γ1_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                      let γ1_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                      let γ1_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                      let value_C := M.alloc (| γ1_0 |) in
                      let value_D := M.alloc (| γ1_1 |) in
                      let value_E := M.alloc (| γ1_2 |) in
                      let value_F := M.alloc (| γ1_3 |) in
                      let value_G := M.alloc (| γ1_4 |) in
                      let value_H := M.alloc (| γ1_5 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              LogicalOp.and (|
                                LogicalOp.and (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "alloc::vec::is_zero::IsZero",
                                      C,
                                      [],
                                      "is_zero",
                                      []
                                    |),
                                    [ M.read (| value_C |) ]
                                  |),
                                  ltac:(M.monadic
                                    (M.call_closure (|
                                      M.get_trait_method (|
                                        "alloc::vec::is_zero::IsZero",
                                        D,
                                        [],
                                        "is_zero",
                                        []
                                      |),
                                      [ M.read (| value_D |) ]
                                    |)))
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "alloc::vec::is_zero::IsZero",
                                      E,
                                      [],
                                      "is_zero",
                                      []
                                    |),
                                    [ M.read (| value_E |) ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "alloc::vec::is_zero::IsZero",
                                    F,
                                    [],
                                    "is_zero",
                                    []
                                  |),
                                  [ M.read (| value_F |) ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  G,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_G |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (C D E F G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self C D E F G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero C D E F G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_C_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_C_D_E_F_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_D_E_F_G_H_.
      Definition Self (D E F G H : Ty.t) : Ty.t := Ty.tuple [ D; E; F; G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero
          (D E F G H : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self D E F G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ1_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                      let γ1_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                      let γ1_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                      let value_D := M.alloc (| γ1_0 |) in
                      let value_E := M.alloc (| γ1_1 |) in
                      let value_F := M.alloc (| γ1_2 |) in
                      let value_G := M.alloc (| γ1_3 |) in
                      let value_H := M.alloc (| γ1_4 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              LogicalOp.and (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "alloc::vec::is_zero::IsZero",
                                    D,
                                    [],
                                    "is_zero",
                                    []
                                  |),
                                  [ M.read (| value_D |) ]
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "alloc::vec::is_zero::IsZero",
                                      E,
                                      [],
                                      "is_zero",
                                      []
                                    |),
                                    [ M.read (| value_E |) ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "alloc::vec::is_zero::IsZero",
                                    F,
                                    [],
                                    "is_zero",
                                    []
                                  |),
                                  [ M.read (| value_F |) ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  G,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_G |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (D E F G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self D E F G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero D E F G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_D_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_D_E_F_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_E_F_G_H_.
      Definition Self (E F G H : Ty.t) : Ty.t := Ty.tuple [ E; F; G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero
          (E F G H : Ty.t)
          (ε : list Value.t)
          (τ : list Ty.t)
          (α : list Value.t)
          : M :=
        let Self : Ty.t := Self E F G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ1_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                      let γ1_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                      let value_E := M.alloc (| γ1_0 |) in
                      let value_F := M.alloc (| γ1_1 |) in
                      let value_G := M.alloc (| γ1_2 |) in
                      let value_H := M.alloc (| γ1_3 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  E,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_E |) ]
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "alloc::vec::is_zero::IsZero",
                                    F,
                                    [],
                                    "is_zero",
                                    []
                                  |),
                                  [ M.read (| value_F |) ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  G,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_G |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (E F G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self E F G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero E F G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_E_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_E_F_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_F_G_H_.
      Definition Self (F G H : Ty.t) : Ty.t := Ty.tuple [ F; G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero (F G H : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self F G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let γ1_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                      let value_F := M.alloc (| γ1_0 |) in
                      let value_G := M.alloc (| γ1_1 |) in
                      let value_H := M.alloc (| γ1_2 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                F,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_F |) ]
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (|
                                  "alloc::vec::is_zero::IsZero",
                                  G,
                                  [],
                                  "is_zero",
                                  []
                                |),
                                [ M.read (| value_G |) ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (F G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self F G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero F G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_F_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_F_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_G_H_.
      Definition Self (G H : Ty.t) : Ty.t := Ty.tuple [ G; H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero (G H : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self G H in
        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_tuple_field (| γ, 0 |) in
                      let γ1_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                      let value_G := M.alloc (| γ1_0 |) in
                      let value_H := M.alloc (| γ1_1 |) in
                      M.alloc (|
                        LogicalOp.and (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "alloc::vec::is_zero::IsZero",
                              G,
                              [],
                              "is_zero",
                              []
                            |),
                            [ M.read (| value_G |) ]
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (|
                                "alloc::vec::is_zero::IsZero",
                                H,
                                [],
                                "is_zero",
                                []
                              |),
                              [ M.read (| value_H |) ]
                            |)))
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (G H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self G H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero G H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_G_where_alloc_vec_is_zero_IsZero_H_for_Tuple_G_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_H_for_Tuple_H_.
      Definition Self (H : Ty.t) : Ty.t := Ty.tuple [ H ].
      
      (*
                  fn is_zero(&self) -> bool{
                      // Destructure tuple to N references
                      // Rust allows to hide generic params by local variable names.
                      #[allow(non_snake_case)]
                      let ($first_arg, $($rest,)* ) = self;
      
                      $first_arg.is_zero()
                          $( && $rest.is_zero() )*
                  }
      *)
      Definition is_zero (H : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self H in
        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_tuple_field (| γ, 0 |) in
                      let value_H := M.alloc (| γ1_0 |) in
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "alloc::vec::is_zero::IsZero",
                            H,
                            [],
                            "is_zero",
                            []
                          |),
                          [ M.read (| value_H |) ]
                        |)
                      |)))
                ]
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (H : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self H)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero H)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_H_for_Tuple_H_.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_core_marker_Sized_T_for_core_option_Option_ref__T.
      Definition Self (T : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::option::Option") [] [ Ty.apply (Ty.path "&") [] [ T ] ].
      
      (*
          fn is_zero(&self) -> bool {
              self.is_none()
          }
      *)
      Definition is_zero (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.apply (Ty.path "core::option::Option") [] [ Ty.apply (Ty.path "&") [] [ T ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero T)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_core_marker_Sized_T_for_core_option_Option_ref__T.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_core_marker_Sized_T_for_core_option_Option_alloc_boxed_Box_T_alloc_alloc_Global.
      Definition Self (T : Ty.t) : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ] ].
      
      (*
          fn is_zero(&self) -> bool {
              self.is_none()
          }
      *)
      Definition is_zero (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_associated_function (|
                Ty.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "alloc::boxed::Box") [] [ T; Ty.path "alloc::alloc::Global" ]
                  ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero T)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_core_marker_Sized_T_for_core_option_Option_alloc_boxed_Box_T_alloc_alloc_Global.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u8.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u8" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u8" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u8.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u16.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u16" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u16" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u16.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u32.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u32" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u32" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u64.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u64" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u64" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u128.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u128" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "u128" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_u128.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_usize.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "usize" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "usize" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_usize.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i8.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i8" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i8" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i8.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i16.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i16" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i16" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i16.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i32.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i32" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i32" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i64.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i64" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i64" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i128.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i128" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "i128" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_i128.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_isize.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "isize" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.apply
                  (Ty.path "core::option::Option")
                  []
                  [ Ty.apply (Ty.path "core::num::nonzero::NonZero") [] [ Ty.path "isize" ] ],
                "is_none",
                []
              |),
              [ M.read (| self |) ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_num_nonzero_NonZero_isize.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u8.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u8" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u8" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u8.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u16.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u16" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u16" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u16.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u32.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u32" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u32" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u64.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u64" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u128.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u128" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "u128" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_u128.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i8.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i8" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i8" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i8.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i16.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i16" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i16" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i16.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i32.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i32" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i32" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i32.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i64.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i64" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i64" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i64.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i128.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i128" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "i128" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_i128.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_usize.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "usize" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_usize.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_isize.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "isize" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      const {
                          let none: Self = unsafe { core::mem::MaybeUninit::zeroed().assume_init() };
                          assert!(none.is_none());
                      }
                      self.is_none()
                  }
      *)
      Definition is_zero (ε : 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.get_constant (| "alloc::vec::is_zero::is_zero_discriminant" |) in
              M.alloc (|
                M.call_closure (|
                  M.get_associated_function (|
                    Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "isize" ],
                    "is_none",
                    []
                  |),
                  [ M.read (| self |) ]
                |)
              |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_isize.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_T_for_core_num_wrapping_Wrapping_T.
      Definition Self (T : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::num::wrapping::Wrapping") [] [ T ].
      
      (*
          fn is_zero(&self) -> bool {
              self.0.is_zero()
          }
      *)
      Definition is_zero (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (| "alloc::vec::is_zero::IsZero", T, [], "is_zero", [] |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::num::wrapping::Wrapping",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero T)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_T_for_core_num_wrapping_Wrapping_T.
    
    Module Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_T_for_core_num_saturating_Saturating_T.
      Definition Self (T : Ty.t) : Ty.t :=
        Ty.apply (Ty.path "core::num::saturating::Saturating") [] [ T ].
      
      (*
          fn is_zero(&self) -> bool {
              self.0.is_zero()
          }
      *)
      Definition is_zero (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
        let Self : Ty.t := Self T in
        match ε, τ, α with
        | [], [], [ self ] =>
          ltac:(M.monadic
            (let self := M.alloc (| self |) in
            M.call_closure (|
              M.get_trait_method (| "alloc::vec::is_zero::IsZero", T, [], "is_zero", [] |),
              [
                M.SubPointer.get_struct_tuple_field (|
                  M.read (| self |),
                  "core::num::saturating::Saturating",
                  0
                |)
              ]
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        forall (T : Ty.t),
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          (Self T)
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method (is_zero T)) ].
    End Impl_alloc_vec_is_zero_IsZero_where_alloc_vec_is_zero_IsZero_T_for_core_num_saturating_Saturating_T.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_bool.
      Definition Self : Ty.t := Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ].
      
      (*
                  fn is_zero(&self) -> bool {
                      // SAFETY: This is *not* a stable layout guarantee, but
                      // inside `core` we're allowed to rely on the current rustc
                      // behaviour that options of bools will be one byte with
                      // no padding, so long as they're nested less than 254 deep.
                      let raw: u8 = unsafe { core::mem::transmute( *self) };
                      raw == 0
                  }
      *)
      Definition is_zero (ε : 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~ raw :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::transmute",
                      [
                        Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ];
                        Ty.path "u8"
                      ]
                    |),
                    [ M.read (| M.read (| self |) |) ]
                  |)
                |) in
              M.alloc (| BinOp.eq (| M.read (| raw |), Value.Integer IntegerKind.U8 0 |) |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_bool.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_option_Option_bool.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ] ].
      
      (*
                  fn is_zero(&self) -> bool {
                      // SAFETY: This is *not* a stable layout guarantee, but
                      // inside `core` we're allowed to rely on the current rustc
                      // behaviour that options of bools will be one byte with
                      // no padding, so long as they're nested less than 254 deep.
                      let raw: u8 = unsafe { core::mem::transmute( *self) };
                      raw == 0
                  }
      *)
      Definition is_zero (ε : 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~ raw :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::transmute",
                      [
                        Ty.apply
                          (Ty.path "core::option::Option")
                          []
                          [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ] ];
                        Ty.path "u8"
                      ]
                    |),
                    [ M.read (| M.read (| self |) |) ]
                  |)
                |) in
              M.alloc (| BinOp.eq (| M.read (| raw |), Value.Integer IntegerKind.U8 0 |) |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_option_Option_bool.
    
    Module Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_option_Option_core_option_Option_bool.
      Definition Self : Ty.t :=
        Ty.apply
          (Ty.path "core::option::Option")
          []
          [
            Ty.apply
              (Ty.path "core::option::Option")
              []
              [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ] ]
          ].
      
      (*
                  fn is_zero(&self) -> bool {
                      // SAFETY: This is *not* a stable layout guarantee, but
                      // inside `core` we're allowed to rely on the current rustc
                      // behaviour that options of bools will be one byte with
                      // no padding, so long as they're nested less than 254 deep.
                      let raw: u8 = unsafe { core::mem::transmute( *self) };
                      raw == 0
                  }
      *)
      Definition is_zero (ε : 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~ raw :=
                M.alloc (|
                  M.call_closure (|
                    M.get_function (|
                      "core::intrinsics::transmute",
                      [
                        Ty.apply
                          (Ty.path "core::option::Option")
                          []
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.apply (Ty.path "core::option::Option") [] [ Ty.path "bool" ] ]
                          ];
                        Ty.path "u8"
                      ]
                    |),
                    [ M.read (| M.read (| self |) |) ]
                  |)
                |) in
              M.alloc (| BinOp.eq (| M.read (| raw |), Value.Integer IntegerKind.U8 0 |) |)
            |)))
        | _, _, _ => M.impossible "wrong number of arguments"
        end.
      
      Axiom Implements :
        M.IsTraitInstance
          "alloc::vec::is_zero::IsZero"
          Self
          (* Trait polymorphic types *) []
          (* Instance *) [ ("is_zero", InstanceField.Method is_zero) ].
    End Impl_alloc_vec_is_zero_IsZero_for_core_option_Option_core_option_Option_core_option_Option_bool.
  End is_zero.
End vec.
