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

Module tuple.
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("eq", InstanceField.Method (eq T)); ("ne", InstanceField.Method (ne T)) ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance "core::cmp::Eq" (Self T) (* Trait polymorphic types *) [] (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__T_for_Tuple_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_T_for_Tuple_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "partial_cmp", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "lt", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "le", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "ge", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "gt", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp T));
          ("lt", InstanceField.Method (lt T));
          ("le", InstanceField.Method (le T));
          ("ge", InstanceField.Method (ge T));
          ("gt", InstanceField.Method (gt T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.call_closure (|
            M.get_trait_method (| "core::cmp::Ord", T, [], "cmp", [] |),
            [
              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
            ]
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default T)) ].
  End Impl_core_default_Default_where_core_default_Default_T_for_Tuple_T_.
  
  Module Impl_core_convert_From_array_Usize_1_T_for_Tuple_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let value_T := M.copy (| γ0_0 |) in
                    M.alloc (| Value.Tuple [ M.read (| value_T |) ] |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 1 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_1_T_for_Tuple_T_.
  
  Module Impl_core_convert_From_Tuple_T__for_array_Usize_1_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 1 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let value_T := M.copy (| γ0_0 |) in
                    M.alloc (| Value.Array [ M.read (| value_T |) ] |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T__for_array_Usize_1_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            M.call_closure (|
              M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
              [
                M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
              ]
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            M.call_closure (|
              M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
              [
                M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
              ]
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("eq", InstanceField.Method (eq U T)); ("ne", InstanceField.Method (ne U T)) ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", U, [ U ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialOrd",
                          T,
                          [ T ],
                          "partial_cmp",
                          []
                        |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", U, [ U ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "lt", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", U, [ U ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "le", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", U, [ U ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "ge", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", U, [ U ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialOrd", T, [ T ], "gt", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp U T));
          ("lt", InstanceField.Method (lt U T));
          ("le", InstanceField.Method (le U T));
          ("ge", InstanceField.Method (ge U T));
          ("gt", InstanceField.Method (gt U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", U, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::Ord", T, [], "cmp", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_U_T_.
    Definition Self (U T : Ty.t) : Ty.t := Ty.tuple [ U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default (U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default U T)) ].
  End Impl_core_default_Default_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_U_T_.
  
  Module Impl_core_convert_From_array_Usize_2_T_for_Tuple_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let value_U := M.copy (| γ0_0 |) in
                    let value_T := M.copy (| γ0_1 |) in
                    M.alloc (| Value.Tuple [ M.read (| value_U |); M.read (| value_T |) ] |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 2 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_2_T_for_Tuple_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T__for_array_Usize_2_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 2 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let value_U := M.copy (| γ0_0 |) in
                    let value_T := M.copy (| γ0_1 |) in
                    M.alloc (| Value.Array [ M.read (| value_U |); M.read (| value_T |) ] |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T__for_array_Usize_2_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                ]
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                ]
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("eq", InstanceField.Method (eq V U T)); ("ne", InstanceField.Method (ne V U T)) ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", V, [ V ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            U,
                            [ U ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  T,
                                  [ T ],
                                  "partial_cmp",
                                  []
                                |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", V, [ V ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            U,
                            [ U ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  T,
                                  [ T ],
                                  "lt",
                                  []
                                |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", V, [ V ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            U,
                            [ U ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  T,
                                  [ T ],
                                  "le",
                                  []
                                |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", V, [ V ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            U,
                            [ U ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  T,
                                  [ T ],
                                  "ge",
                                  []
                                |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", V, [ V ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            U,
                            [ U ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialOrd",
                                  T,
                                  [ T ],
                                  "gt",
                                  []
                                |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp V U T));
          ("lt", InstanceField.Method (lt V U T));
          ("le", InstanceField.Method (le V U T));
          ("ge", InstanceField.Method (ge V U T));
          ("gt", InstanceField.Method (gt V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", V, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", U, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (| "core::cmp::Ord", T, [], "cmp", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_V_U_T_.
    Definition Self (V U T : Ty.t) : Ty.t := Ty.tuple [ V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default (V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_3_T_for_Tuple_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let value_V := M.copy (| γ0_0 |) in
                    let value_U := M.copy (| γ0_1 |) in
                    let value_T := M.copy (| γ0_2 |) in
                    M.alloc (|
                      Value.Tuple
                        [ M.read (| value_V |); M.read (| value_U |); M.read (| value_T |) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 3 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_3_T_for_Tuple_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T__for_array_Usize_3_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 3 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let value_V := M.copy (| γ0_0 |) in
                    let value_U := M.copy (| γ0_1 |) in
                    let value_T := M.copy (| γ0_2 |) in
                    M.alloc (|
                      Value.Array
                        [ M.read (| value_V |); M.read (| value_U |); M.read (| value_T |) ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T__for_array_Usize_3_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("eq", InstanceField.Method (eq W V U T)); ("ne", InstanceField.Method (ne W V U T)) ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", W, [ W ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            V,
                            [ V ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    U,
                                    [ U ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialOrd",
                                          T,
                                          [ T ],
                                          "partial_cmp",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", W, [ W ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            V,
                            [ V ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    U,
                                    [ U ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialOrd",
                                          T,
                                          [ T ],
                                          "lt",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                        ]
                                      |)
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", W, [ W ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            V,
                            [ V ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    U,
                                    [ U ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialOrd",
                                          T,
                                          [ T ],
                                          "le",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                        ]
                                      |)
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", W, [ W ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            V,
                            [ V ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    U,
                                    [ U ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialOrd",
                                          T,
                                          [ T ],
                                          "ge",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                        ]
                                      |)
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", W, [ W ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            V,
                            [ V ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    U,
                                    [ U ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialOrd",
                                          T,
                                          [ T ],
                                          "gt",
                                          []
                                        |),
                                        [
                                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                        ]
                                      |)
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp W V U T));
          ("lt", InstanceField.Method (lt W V U T));
          ("le", InstanceField.Method (le W V U T));
          ("ge", InstanceField.Method (ge W V U T));
          ("gt", InstanceField.Method (gt W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", W, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", V, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", U, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (| "core::cmp::Ord", T, [], "cmp", [] |),
                                        [
                                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_W_V_U_T_.
    Definition Self (W V U T : Ty.t) : Ty.t := Ty.tuple [ W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default (W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_4_T_for_Tuple_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let value_W := M.copy (| γ0_0 |) in
                    let value_V := M.copy (| γ0_1 |) in
                    let value_U := M.copy (| γ0_2 |) in
                    let value_T := M.copy (| γ0_3 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_4_T_for_Tuple_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T__for_array_Usize_4_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 4 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let value_W := M.copy (| γ0_0 |) in
                    let value_V := M.copy (| γ0_1 |) in
                    let value_U := M.copy (| γ0_2 |) in
                    let value_T := M.copy (| γ0_3 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T__for_array_Usize_4_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                    ]
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                    ]
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [ ("eq", InstanceField.Method (eq X W V U T)); ("ne", InstanceField.Method (ne X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", X, [ X ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            W,
                            [ W ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    V,
                                    [ V ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            U,
                                            [ U ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialOrd",
                                                  T,
                                                  [ T ],
                                                  "partial_cmp",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| self |),
                                                    4
                                                  |);
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| other |),
                                                    4
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", X, [ X ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            W,
                            [ W ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    V,
                                    [ V ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            U,
                                            [ U ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialOrd",
                                                  T,
                                                  [ T ],
                                                  "lt",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| self |),
                                                    4
                                                  |);
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| other |),
                                                    4
                                                  |)
                                                ]
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", X, [ X ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            W,
                            [ W ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    V,
                                    [ V ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            U,
                                            [ U ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialOrd",
                                                  T,
                                                  [ T ],
                                                  "le",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| self |),
                                                    4
                                                  |);
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| other |),
                                                    4
                                                  |)
                                                ]
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", X, [ X ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            W,
                            [ W ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    V,
                                    [ V ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            U,
                                            [ U ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialOrd",
                                                  T,
                                                  [ T ],
                                                  "ge",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| self |),
                                                    4
                                                  |);
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| other |),
                                                    4
                                                  |)
                                                ]
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", X, [ X ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            W,
                            [ W ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    V,
                                    [ V ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            U,
                                            [ U ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialOrd",
                                                  T,
                                                  [ T ],
                                                  "gt",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| self |),
                                                    4
                                                  |);
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| other |),
                                                    4
                                                  |)
                                                ]
                                              |)
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp X W V U T));
          ("lt", InstanceField.Method (lt X W V U T));
          ("le", InstanceField.Method (le X W V U T));
          ("ge", InstanceField.Method (ge X W V U T));
          ("gt", InstanceField.Method (gt X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp (X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", X, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", W, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", V, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            U,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::Ord",
                                                  T,
                                                  [],
                                                  "cmp",
                                                  []
                                                |),
                                                [
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| self |),
                                                    4
                                                  |);
                                                  M.SubPointer.get_tuple_field (|
                                                    M.read (| other |),
                                                    4
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_X_W_V_U_T_.
    Definition Self (X W V U T : Ty.t) : Ty.t := Ty.tuple [ X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_5_T_for_Tuple_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let value_X := M.copy (| γ0_0 |) in
                    let value_W := M.copy (| γ0_1 |) in
                    let value_V := M.copy (| γ0_2 |) in
                    let value_U := M.copy (| γ0_3 |) in
                    let value_T := M.copy (| γ0_4 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 5 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_5_T_for_Tuple_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T__for_array_Usize_5_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 5 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let value_X := M.copy (| γ0_0 |) in
                    let value_W := M.copy (| γ0_1 |) in
                    let value_V := M.copy (| γ0_2 |) in
                    let value_U := M.copy (| γ0_3 |) in
                    let value_T := M.copy (| γ0_4 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T__for_array_Usize_5_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                      ]
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                      ]
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq Y X W V U T));
          ("ne", InstanceField.Method (ne Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Y, [ Y ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            X,
                            [ X ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    W,
                                    [ W ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            V,
                                            [ V ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    U,
                                                    [ U ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialOrd",
                                                          T,
                                                          [ T ],
                                                          "partial_cmp",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| self |),
                                                            5
                                                          |);
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| other |),
                                                            5
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Y, [ Y ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            X,
                            [ X ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    W,
                                    [ W ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            V,
                                            [ V ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    U,
                                                    [ U ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialOrd",
                                                          T,
                                                          [ T ],
                                                          "lt",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| self |),
                                                            5
                                                          |);
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| other |),
                                                            5
                                                          |)
                                                        ]
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Y, [ Y ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            X,
                            [ X ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    W,
                                    [ W ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            V,
                                            [ V ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    U,
                                                    [ U ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialOrd",
                                                          T,
                                                          [ T ],
                                                          "le",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| self |),
                                                            5
                                                          |);
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| other |),
                                                            5
                                                          |)
                                                        ]
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Y, [ Y ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            X,
                            [ X ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    W,
                                    [ W ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            V,
                                            [ V ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    U,
                                                    [ U ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialOrd",
                                                          T,
                                                          [ T ],
                                                          "ge",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| self |),
                                                            5
                                                          |);
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| other |),
                                                            5
                                                          |)
                                                        ]
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Y, [ Y ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            X,
                            [ X ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    W,
                                    [ W ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            V,
                                            [ V ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    U,
                                                    [ U ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialOrd",
                                                          T,
                                                          [ T ],
                                                          "gt",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| self |),
                                                            5
                                                          |);
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| other |),
                                                            5
                                                          |)
                                                        ]
                                                      |)
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp Y X W V U T));
          ("lt", InstanceField.Method (lt Y X W V U T));
          ("le", InstanceField.Method (le Y X W V U T));
          ("ge", InstanceField.Method (ge Y X W V U T));
          ("gt", InstanceField.Method (gt Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp (Y X W V U T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", Y, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", X, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", W, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            V,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    U,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::Ord",
                                                          T,
                                                          [],
                                                          "cmp",
                                                          []
                                                        |),
                                                        [
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| self |),
                                                            5
                                                          |);
                                                          M.SubPointer.get_tuple_field (|
                                                            M.read (| other |),
                                                            5
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_Y_X_W_V_U_T_.
    Definition Self (Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_6_T_for_Tuple_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let value_Y := M.copy (| γ0_0 |) in
                    let value_X := M.copy (| γ0_1 |) in
                    let value_W := M.copy (| γ0_2 |) in
                    let value_V := M.copy (| γ0_3 |) in
                    let value_U := M.copy (| γ0_4 |) in
                    let value_T := M.copy (| γ0_5 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 6 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_6_T_for_Tuple_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T__for_array_Usize_6_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 6 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let value_Y := M.copy (| γ0_0 |) in
                    let value_X := M.copy (| γ0_1 |) in
                    let value_W := M.copy (| γ0_2 |) in
                    let value_V := M.copy (| γ0_3 |) in
                    let value_U := M.copy (| γ0_4 |) in
                    let value_T := M.copy (| γ0_5 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T__for_array_Usize_6_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                        ]
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                        ]
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq Z Y X W V U T));
          ("ne", InstanceField.Method (ne Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Z, [ Z ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Y,
                            [ Y ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    X,
                                    [ X ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            W,
                                            [ W ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    V,
                                                    [ V ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            U,
                                                            [ U ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let _ :=
                                                              M.is_struct_tuple (|
                                                                γ0_0,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialOrd",
                                                                  T,
                                                                  [ T ],
                                                                  "partial_cmp",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| self |),
                                                                    6
                                                                  |);
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| other |),
                                                                    6
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Z, [ Z ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Y,
                            [ Y ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    X,
                                    [ X ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            W,
                                            [ W ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    V,
                                                    [ V ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            U,
                                                            [ U ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialOrd",
                                                                  T,
                                                                  [ T ],
                                                                  "lt",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| self |),
                                                                    6
                                                                  |);
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| other |),
                                                                    6
                                                                  |)
                                                                ]
                                                              |)
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Z, [ Z ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Y,
                            [ Y ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    X,
                                    [ X ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            W,
                                            [ W ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    V,
                                                    [ V ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            U,
                                                            [ U ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialOrd",
                                                                  T,
                                                                  [ T ],
                                                                  "le",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| self |),
                                                                    6
                                                                  |);
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| other |),
                                                                    6
                                                                  |)
                                                                ]
                                                              |)
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Z, [ Z ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Y,
                            [ Y ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    X,
                                    [ X ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            W,
                                            [ W ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    V,
                                                    [ V ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            U,
                                                            [ U ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialOrd",
                                                                  T,
                                                                  [ T ],
                                                                  "ge",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| self |),
                                                                    6
                                                                  |);
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| other |),
                                                                    6
                                                                  |)
                                                                ]
                                                              |)
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", Z, [ Z ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Y,
                            [ Y ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    X,
                                    [ X ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            W,
                                            [ W ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    V,
                                                    [ V ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            U,
                                                            [ U ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialOrd",
                                                                  T,
                                                                  [ T ],
                                                                  "gt",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| self |),
                                                                    6
                                                                  |);
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| other |),
                                                                    6
                                                                  |)
                                                                ]
                                                              |)
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp Z Y X W V U T));
          ("lt", InstanceField.Method (lt Z Y X W V U T));
          ("le", InstanceField.Method (le Z Y X W V U T));
          ("ge", InstanceField.Method (ge Z Y X W V U T));
          ("gt", InstanceField.Method (gt Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", Z, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", Y, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", X, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            W,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    V,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::Ord",
                                                            U,
                                                            [],
                                                            "cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::Ord",
                                                                  T,
                                                                  [],
                                                                  "cmp",
                                                                  []
                                                                |),
                                                                [
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| self |),
                                                                    6
                                                                  |);
                                                                  M.SubPointer.get_tuple_field (|
                                                                    M.read (| other |),
                                                                    6
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp Z Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_Z_Y_X_W_V_U_T_.
    Definition Self (Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ Z; Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self Z Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Z, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default Z Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_7_T_for_Tuple_T_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                    let value_Z := M.copy (| γ0_0 |) in
                    let value_Y := M.copy (| γ0_1 |) in
                    let value_X := M.copy (| γ0_2 |) in
                    let value_W := M.copy (| γ0_3 |) in
                    let value_V := M.copy (| γ0_4 |) in
                    let value_U := M.copy (| γ0_5 |) in
                    let value_T := M.copy (| γ0_6 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 7 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_7_T_for_Tuple_T_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T_T__for_array_Usize_7_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 7 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                    let value_Z := M.copy (| γ0_0 |) in
                    let value_Y := M.copy (| γ0_1 |) in
                    let value_X := M.copy (| γ0_2 |) in
                    let value_W := M.copy (| γ0_3 |) in
                    let value_V := M.copy (| γ0_4 |) in
                    let value_U := M.copy (| γ0_5 |) in
                    let value_T := M.copy (| γ0_6 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T_T__for_array_Usize_7_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                          ]
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "eq", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                          ]
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "ne", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq A Z Y X W V U T));
          ("ne", InstanceField.Method (ne A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", A, [ A ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Z,
                            [ Z ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Y,
                                    [ Y ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            X,
                                            [ X ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    W,
                                                    [ W ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            V,
                                                            [ V ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let _ :=
                                                              M.is_struct_tuple (|
                                                                γ0_0,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    U,
                                                                    [ U ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ0_0 :=
                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                        γ,
                                                                        "core::option::Option::Some",
                                                                        0
                                                                      |) in
                                                                    let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ0_0,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialOrd",
                                                                          T,
                                                                          [ T ],
                                                                          "partial_cmp",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| self |),
                                                                            7
                                                                          |);
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| other |),
                                                                            7
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", A, [ A ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Z,
                            [ Z ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Y,
                                    [ Y ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            X,
                                            [ X ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    W,
                                                    [ W ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            V,
                                                            [ V ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    U,
                                                                    [ U ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialOrd",
                                                                          T,
                                                                          [ T ],
                                                                          "lt",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| self |),
                                                                            7
                                                                          |);
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| other |),
                                                                            7
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", A, [ A ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Z,
                            [ Z ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Y,
                                    [ Y ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            X,
                                            [ X ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    W,
                                                    [ W ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            V,
                                                            [ V ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    U,
                                                                    [ U ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialOrd",
                                                                          T,
                                                                          [ T ],
                                                                          "le",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| self |),
                                                                            7
                                                                          |);
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| other |),
                                                                            7
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", A, [ A ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Z,
                            [ Z ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Y,
                                    [ Y ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            X,
                                            [ X ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    W,
                                                    [ W ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            V,
                                                            [ V ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    U,
                                                                    [ U ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialOrd",
                                                                          T,
                                                                          [ T ],
                                                                          "ge",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| self |),
                                                                            7
                                                                          |);
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| other |),
                                                                            7
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", A, [ A ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            Z,
                            [ Z ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Y,
                                    [ Y ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            X,
                                            [ X ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    W,
                                                    [ W ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            V,
                                                            [ V ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    U,
                                                                    [ U ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialOrd",
                                                                          T,
                                                                          [ T ],
                                                                          "gt",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| self |),
                                                                            7
                                                                          |);
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| other |),
                                                                            7
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp A Z Y X W V U T));
          ("lt", InstanceField.Method (lt A Z Y X W V U T));
          ("le", InstanceField.Method (le A Z Y X W V U T));
          ("ge", InstanceField.Method (ge A Z Y X W V U T));
          ("gt", InstanceField.Method (gt A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", A, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", Z, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", Y, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            X,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    W,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::Ord",
                                                            V,
                                                            [],
                                                            "cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::Ord",
                                                                    U,
                                                                    [],
                                                                    "cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::Ord",
                                                                          T,
                                                                          [],
                                                                          "cmp",
                                                                          []
                                                                        |),
                                                                        [
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| self |),
                                                                            7
                                                                          |);
                                                                          M.SubPointer.get_tuple_field (|
                                                                            M.read (| other |),
                                                                            7
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp A Z Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
    Definition Self (A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", A, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Z, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default A Z Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_8_T_for_Tuple_T_T_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                    let value_A := M.copy (| γ0_0 |) in
                    let value_Z := M.copy (| γ0_1 |) in
                    let value_Y := M.copy (| γ0_2 |) in
                    let value_X := M.copy (| γ0_3 |) in
                    let value_W := M.copy (| γ0_4 |) in
                    let value_V := M.copy (| γ0_5 |) in
                    let value_U := M.copy (| γ0_6 |) in
                    let value_T := M.copy (| γ0_7 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 8 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_8_T_for_Tuple_T_T_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T__for_array_Usize_8_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 8 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_tuple_field (| γ, 7 |) in
                    let value_A := M.copy (| γ0_0 |) in
                    let value_Z := M.copy (| γ0_1 |) in
                    let value_Y := M.copy (| γ0_2 |) in
                    let value_X := M.copy (| γ0_3 |) in
                    let value_W := M.copy (| γ0_4 |) in
                    let value_V := M.copy (| γ0_5 |) in
                    let value_U := M.copy (| γ0_6 |) in
                    let value_T := M.copy (| γ0_7 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T__for_array_Usize_8_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        LogicalOp.and (|
                          M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "eq", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                            ]
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "eq", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "eq", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        LogicalOp.or (|
                          M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "ne", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                            ]
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "ne", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "ne", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq B A Z Y X W V U T));
          ("ne", InstanceField.Method (ne B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", B, [ B ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            A,
                            [ A ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Z,
                                    [ Z ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Y,
                                            [ Y ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    X,
                                                    [ X ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            W,
                                                            [ W ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let _ :=
                                                              M.is_struct_tuple (|
                                                                γ0_0,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    V,
                                                                    [ V ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ0_0 :=
                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                        γ,
                                                                        "core::option::Option::Some",
                                                                        0
                                                                      |) in
                                                                    let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ0_0,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            U,
                                                                            [ U ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ0_0 :=
                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                γ,
                                                                                "core::option::Option::Some",
                                                                                0
                                                                              |) in
                                                                            let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ0_0,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialOrd",
                                                                                  T,
                                                                                  [ T ],
                                                                                  "partial_cmp",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      self
                                                                                    |),
                                                                                    8
                                                                                  |);
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      other
                                                                                    |),
                                                                                    8
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", B, [ B ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            A,
                            [ A ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Z,
                                    [ Z ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Y,
                                            [ Y ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    X,
                                                    [ X ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            W,
                                                            [ W ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    V,
                                                                    [ V ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            U,
                                                                            [ U ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialOrd",
                                                                                  T,
                                                                                  [ T ],
                                                                                  "lt",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      self
                                                                                    |),
                                                                                    8
                                                                                  |);
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      other
                                                                                    |),
                                                                                    8
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", B, [ B ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            A,
                            [ A ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Z,
                                    [ Z ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Y,
                                            [ Y ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    X,
                                                    [ X ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            W,
                                                            [ W ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    V,
                                                                    [ V ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            U,
                                                                            [ U ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialOrd",
                                                                                  T,
                                                                                  [ T ],
                                                                                  "le",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      self
                                                                                    |),
                                                                                    8
                                                                                  |);
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      other
                                                                                    |),
                                                                                    8
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", B, [ B ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            A,
                            [ A ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Z,
                                    [ Z ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Y,
                                            [ Y ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    X,
                                                    [ X ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            W,
                                                            [ W ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    V,
                                                                    [ V ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            U,
                                                                            [ U ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialOrd",
                                                                                  T,
                                                                                  [ T ],
                                                                                  "ge",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      self
                                                                                    |),
                                                                                    8
                                                                                  |);
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      other
                                                                                    |),
                                                                                    8
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", B, [ B ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            A,
                            [ A ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    Z,
                                    [ Z ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Y,
                                            [ Y ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    X,
                                                    [ X ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            W,
                                                            [ W ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    V,
                                                                    [ V ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            U,
                                                                            [ U ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialOrd",
                                                                                  T,
                                                                                  [ T ],
                                                                                  "gt",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      self
                                                                                    |),
                                                                                    8
                                                                                  |);
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      other
                                                                                    |),
                                                                                    8
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp B A Z Y X W V U T));
          ("lt", InstanceField.Method (lt B A Z Y X W V U T));
          ("le", InstanceField.Method (le B A Z Y X W V U T));
          ("ge", InstanceField.Method (ge B A Z Y X W V U T));
          ("gt", InstanceField.Method (gt B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", B, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", A, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", Z, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            Y,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    X,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::Ord",
                                                            W,
                                                            [],
                                                            "cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::Ord",
                                                                    V,
                                                                    [],
                                                                    "cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::Ord",
                                                                            U,
                                                                            [],
                                                                            "cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::Ord",
                                                                                  T,
                                                                                  [],
                                                                                  "cmp",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      self
                                                                                    |),
                                                                                    8
                                                                                  |);
                                                                                  M.SubPointer.get_tuple_field (|
                                                                                    M.read (|
                                                                                      other
                                                                                    |),
                                                                                    8
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp B A Z Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (B A Z Y X W V U T : Ty.t) : Ty.t := Ty.tuple [ B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", B, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", A, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Z, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default B A Z Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_9_T_for_Tuple_T_T_T_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_slice_index (| γ, 8 |) in
                    let value_B := M.copy (| γ0_0 |) in
                    let value_A := M.copy (| γ0_1 |) in
                    let value_Z := M.copy (| γ0_2 |) in
                    let value_Y := M.copy (| γ0_3 |) in
                    let value_X := M.copy (| γ0_4 |) in
                    let value_W := M.copy (| γ0_5 |) in
                    let value_V := M.copy (| γ0_6 |) in
                    let value_U := M.copy (| γ0_7 |) in
                    let value_T := M.copy (| γ0_8 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 9 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_9_T_for_Tuple_T_T_T_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T__for_array_Usize_9_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 9 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_tuple_field (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_tuple_field (| γ, 8 |) in
                    let value_B := M.copy (| γ0_0 |) in
                    let value_A := M.copy (| γ0_1 |) in
                    let value_Z := M.copy (| γ0_2 |) in
                    let value_Y := M.copy (| γ0_3 |) in
                    let value_X := M.copy (| γ0_4 |) in
                    let value_W := M.copy (| γ0_5 |) in
                    let value_V := M.copy (| γ0_6 |) in
                    let value_U := M.copy (| γ0_7 |) in
                    let value_T := M.copy (| γ0_8 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T__for_array_Usize_9_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_C_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", C, [ C ], "eq", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                              ]
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "eq", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                                ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "eq", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "eq", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 9 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 9 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        LogicalOp.or (|
                          LogicalOp.or (|
                            M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", C, [ C ], "ne", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                              ]
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "ne", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                                ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "ne", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "ne", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 9 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 9 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq C B A Z Y X W V U T));
          ("ne", InstanceField.Method (ne C B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_C_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_C_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_C_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__C_where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__C_where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_C_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_C_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_C_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", C, [ C ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            B,
                            [ B ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    A,
                                    [ A ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Z,
                                            [ Z ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Y,
                                                    [ Y ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            X,
                                                            [ X ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let _ :=
                                                              M.is_struct_tuple (|
                                                                γ0_0,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    W,
                                                                    [ W ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ0_0 :=
                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                        γ,
                                                                        "core::option::Option::Some",
                                                                        0
                                                                      |) in
                                                                    let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ0_0,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            V,
                                                                            [ V ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ0_0 :=
                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                γ,
                                                                                "core::option::Option::Some",
                                                                                0
                                                                              |) in
                                                                            let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ0_0,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    U,
                                                                                    [ U ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ0_0 :=
                                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                                        γ,
                                                                                        "core::option::Option::Some",
                                                                                        0
                                                                                      |) in
                                                                                    let _ :=
                                                                                      M.is_struct_tuple (|
                                                                                        γ0_0,
                                                                                        "core::cmp::Ordering::Equal"
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialOrd",
                                                                                          T,
                                                                                          [ T ],
                                                                                          "partial_cmp",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              self
                                                                                            |),
                                                                                            9
                                                                                          |);
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              other
                                                                                            |),
                                                                                            9
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let ordering :=
                                                                                      M.copy (|
                                                                                        γ
                                                                                      |) in
                                                                                    ordering))
                                                                              ]
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", C, [ C ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            B,
                            [ B ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    A,
                                    [ A ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Z,
                                            [ Z ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Y,
                                                    [ Y ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            X,
                                                            [ X ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    W,
                                                                    [ W ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            V,
                                                                            [ V ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    U,
                                                                                    [ U ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Less"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialOrd",
                                                                                          T,
                                                                                          [ T ],
                                                                                          "lt",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              self
                                                                                            |),
                                                                                            9
                                                                                          |);
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              other
                                                                                            |),
                                                                                            9
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", C, [ C ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            B,
                            [ B ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    A,
                                    [ A ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Z,
                                            [ Z ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Y,
                                                    [ Y ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            X,
                                                            [ X ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    W,
                                                                    [ W ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            V,
                                                                            [ V ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    U,
                                                                                    [ U ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Less"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialOrd",
                                                                                          T,
                                                                                          [ T ],
                                                                                          "le",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              self
                                                                                            |),
                                                                                            9
                                                                                          |);
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              other
                                                                                            |),
                                                                                            9
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", C, [ C ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            B,
                            [ B ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    A,
                                    [ A ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Z,
                                            [ Z ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Y,
                                                    [ Y ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            X,
                                                            [ X ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    W,
                                                                    [ W ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            V,
                                                                            [ V ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    U,
                                                                                    [ U ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialOrd",
                                                                                          T,
                                                                                          [ T ],
                                                                                          "ge",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              self
                                                                                            |),
                                                                                            9
                                                                                          |);
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              other
                                                                                            |),
                                                                                            9
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", C, [ C ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            B,
                            [ B ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    A,
                                    [ A ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            Z,
                                            [ Z ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Y,
                                                    [ Y ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            X,
                                                            [ X ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    W,
                                                                    [ W ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            V,
                                                                            [ V ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    U,
                                                                                    [ U ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialOrd",
                                                                                          T,
                                                                                          [ T ],
                                                                                          "gt",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              self
                                                                                            |),
                                                                                            9
                                                                                          |);
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              other
                                                                                            |),
                                                                                            9
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp C B A Z Y X W V U T));
          ("lt", InstanceField.Method (lt C B A Z Y X W V U T));
          ("le", InstanceField.Method (le C B A Z Y X W V U T));
          ("ge", InstanceField.Method (ge C B A Z Y X W V U T));
          ("gt", InstanceField.Method (gt C B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_C_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_C_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", C, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", B, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", A, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            Z,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    Y,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::Ord",
                                                            X,
                                                            [],
                                                            "cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::Ord",
                                                                    W,
                                                                    [],
                                                                    "cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::Ord",
                                                                            V,
                                                                            [],
                                                                            "cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::Ord",
                                                                                    U,
                                                                                    [],
                                                                                    "cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let _ :=
                                                                                      M.is_struct_tuple (|
                                                                                        γ,
                                                                                        "core::cmp::Ordering::Equal"
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::Ord",
                                                                                          T,
                                                                                          [],
                                                                                          "cmp",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              self
                                                                                            |),
                                                                                            9
                                                                                          |);
                                                                                          M.SubPointer.get_tuple_field (|
                                                                                            M.read (|
                                                                                              other
                                                                                            |),
                                                                                            9
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let ordering :=
                                                                                      M.copy (|
                                                                                        γ
                                                                                      |) in
                                                                                    ordering))
                                                                              ]
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp C B A Z Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_C_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_C_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", C, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", B, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", A, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Z, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default C B A Z Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_C_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_10_T_for_Tuple_T_T_T_T_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_slice_index (| γ, 8 |) in
                    let γ0_9 := M.SubPointer.get_slice_index (| γ, 9 |) in
                    let value_C := M.copy (| γ0_0 |) in
                    let value_B := M.copy (| γ0_1 |) in
                    let value_A := M.copy (| γ0_2 |) in
                    let value_Z := M.copy (| γ0_3 |) in
                    let value_Y := M.copy (| γ0_4 |) in
                    let value_X := M.copy (| γ0_5 |) in
                    let value_W := M.copy (| γ0_6 |) in
                    let value_V := M.copy (| γ0_7 |) in
                    let value_U := M.copy (| γ0_8 |) in
                    let value_T := M.copy (| γ0_9 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_C |);
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 10 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_10_T_for_Tuple_T_T_T_T_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T_T__for_array_Usize_10_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 10 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_tuple_field (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_tuple_field (| γ, 8 |) in
                    let γ0_9 := M.SubPointer.get_tuple_field (| γ, 9 |) in
                    let value_C := M.copy (| γ0_0 |) in
                    let value_B := M.copy (| γ0_1 |) in
                    let value_A := M.copy (| γ0_2 |) in
                    let value_Z := M.copy (| γ0_3 |) in
                    let value_Y := M.copy (| γ0_4 |) in
                    let value_X := M.copy (| γ0_5 |) in
                    let value_W := M.copy (| γ0_6 |) in
                    let value_V := M.copy (| γ0_7 |) in
                    let value_U := M.copy (| γ0_8 |) in
                    let value_T := M.copy (| γ0_9 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_C |);
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T_T__for_array_Usize_10_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_D_where_core_cmp_PartialEq_C_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", D, [ D ], "eq", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                                ]
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    C,
                                    [ C ],
                                    "eq",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                                  ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "eq", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "eq", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "eq", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 9 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 9 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 10 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 10 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        LogicalOp.or (|
                          LogicalOp.or (|
                            LogicalOp.or (|
                              M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", D, [ D ], "ne", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                                ]
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    C,
                                    [ C ],
                                    "ne",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                                  ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "ne", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "ne", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "ne", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 9 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 9 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 10 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 10 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq D C B A Z Y X W V U T));
          ("ne", InstanceField.Method (ne D C B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_D_where_core_cmp_PartialEq_C_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_D_where_core_cmp_Eq_C_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_D_where_core_cmp_Eq_C_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__D_where_core_marker_ConstParamTy__C_where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__D_where_core_marker_ConstParamTy__C_where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_D_where_core_marker_UnsizedConstParamTy_C_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_D_where_core_marker_UnsizedConstParamTy_C_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_D_where_core_cmp_PartialOrd_C_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", D, [ D ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            C,
                            [ C ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    B,
                                    [ B ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            A,
                                            [ A ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Z,
                                                    [ Z ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Y,
                                                            [ Y ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let _ :=
                                                              M.is_struct_tuple (|
                                                                γ0_0,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    X,
                                                                    [ X ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ0_0 :=
                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                        γ,
                                                                        "core::option::Option::Some",
                                                                        0
                                                                      |) in
                                                                    let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ0_0,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            W,
                                                                            [ W ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ0_0 :=
                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                γ,
                                                                                "core::option::Option::Some",
                                                                                0
                                                                              |) in
                                                                            let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ0_0,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    V,
                                                                                    [ V ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ0_0 :=
                                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                                        γ,
                                                                                        "core::option::Option::Some",
                                                                                        0
                                                                                      |) in
                                                                                    let _ :=
                                                                                      M.is_struct_tuple (|
                                                                                        γ0_0,
                                                                                        "core::cmp::Ordering::Equal"
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            U,
                                                                                            [ U ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ0_0 :=
                                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                                γ,
                                                                                                "core::option::Option::Some",
                                                                                                0
                                                                                              |) in
                                                                                            let _ :=
                                                                                              M.is_struct_tuple (|
                                                                                                γ0_0,
                                                                                                "core::cmp::Ordering::Equal"
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialOrd",
                                                                                                  T,
                                                                                                  [
                                                                                                    T
                                                                                                  ],
                                                                                                  "partial_cmp",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      self
                                                                                                    |),
                                                                                                    10
                                                                                                  |);
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      other
                                                                                                    |),
                                                                                                    10
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  ordering :=
                                                                                              M.copy (|
                                                                                                γ
                                                                                              |) in
                                                                                            ordering))
                                                                                      ]
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let ordering :=
                                                                                      M.copy (|
                                                                                        γ
                                                                                      |) in
                                                                                    ordering))
                                                                              ]
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", D, [ D ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            C,
                            [ C ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    B,
                                    [ B ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            A,
                                            [ A ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Z,
                                                    [ Z ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Y,
                                                            [ Y ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    X,
                                                                    [ X ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            W,
                                                                            [ W ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    V,
                                                                                    [ V ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Less"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            U,
                                                                                            [ U ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Less"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialOrd",
                                                                                                  T,
                                                                                                  [
                                                                                                    T
                                                                                                  ],
                                                                                                  "lt",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      self
                                                                                                    |),
                                                                                                    10
                                                                                                  |);
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      other
                                                                                                    |),
                                                                                                    10
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", D, [ D ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            C,
                            [ C ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    B,
                                    [ B ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            A,
                                            [ A ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Z,
                                                    [ Z ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Y,
                                                            [ Y ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    X,
                                                                    [ X ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            W,
                                                                            [ W ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    V,
                                                                                    [ V ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Less"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            U,
                                                                                            [ U ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Less"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialOrd",
                                                                                                  T,
                                                                                                  [
                                                                                                    T
                                                                                                  ],
                                                                                                  "le",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      self
                                                                                                    |),
                                                                                                    10
                                                                                                  |);
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      other
                                                                                                    |),
                                                                                                    10
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", D, [ D ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            C,
                            [ C ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    B,
                                    [ B ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            A,
                                            [ A ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Z,
                                                    [ Z ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Y,
                                                            [ Y ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    X,
                                                                    [ X ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            W,
                                                                            [ W ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    V,
                                                                                    [ V ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            U,
                                                                                            [ U ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Greater"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialOrd",
                                                                                                  T,
                                                                                                  [
                                                                                                    T
                                                                                                  ],
                                                                                                  "ge",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      self
                                                                                                    |),
                                                                                                    10
                                                                                                  |);
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      other
                                                                                                    |),
                                                                                                    10
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", D, [ D ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            C,
                            [ C ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    B,
                                    [ B ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            A,
                                            [ A ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    Z,
                                                    [ Z ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Y,
                                                            [ Y ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    X,
                                                                    [ X ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            W,
                                                                            [ W ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    V,
                                                                                    [ V ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            U,
                                                                                            [ U ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Greater"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialOrd",
                                                                                                  T,
                                                                                                  [
                                                                                                    T
                                                                                                  ],
                                                                                                  "gt",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      self
                                                                                                    |),
                                                                                                    10
                                                                                                  |);
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      other
                                                                                                    |),
                                                                                                    10
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp D C B A Z Y X W V U T));
          ("lt", InstanceField.Method (lt D C B A Z Y X W V U T));
          ("le", InstanceField.Method (le D C B A Z Y X W V U T));
          ("ge", InstanceField.Method (ge D C B A Z Y X W V U T));
          ("gt", InstanceField.Method (gt D C B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_D_where_core_cmp_PartialOrd_C_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_D_where_core_cmp_Ord_C_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", D, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", C, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", B, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            A,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    Z,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::Ord",
                                                            Y,
                                                            [],
                                                            "cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::Ord",
                                                                    X,
                                                                    [],
                                                                    "cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::Ord",
                                                                            W,
                                                                            [],
                                                                            "cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::Ord",
                                                                                    V,
                                                                                    [],
                                                                                    "cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let _ :=
                                                                                      M.is_struct_tuple (|
                                                                                        γ,
                                                                                        "core::cmp::Ordering::Equal"
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::Ord",
                                                                                            U,
                                                                                            [],
                                                                                            "cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  _ :=
                                                                                              M.is_struct_tuple (|
                                                                                                γ,
                                                                                                "core::cmp::Ordering::Equal"
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::Ord",
                                                                                                  T,
                                                                                                  [],
                                                                                                  "cmp",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      self
                                                                                                    |),
                                                                                                    10
                                                                                                  |);
                                                                                                  M.SubPointer.get_tuple_field (|
                                                                                                    M.read (|
                                                                                                      other
                                                                                                    |),
                                                                                                    10
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  ordering :=
                                                                                              M.copy (|
                                                                                                γ
                                                                                              |) in
                                                                                            ordering))
                                                                                      ]
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let ordering :=
                                                                                      M.copy (|
                                                                                        γ
                                                                                      |) in
                                                                                    ordering))
                                                                              ]
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp D C B A Z Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_D_where_core_cmp_Ord_C_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_D_where_core_default_Default_C_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", D, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", C, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", B, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", A, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Z, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default D C B A Z Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_D_where_core_default_Default_C_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_11_T_for_Tuple_T_T_T_T_T_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_slice_index (| γ, 8 |) in
                    let γ0_9 := M.SubPointer.get_slice_index (| γ, 9 |) in
                    let γ0_10 := M.SubPointer.get_slice_index (| γ, 10 |) in
                    let value_D := M.copy (| γ0_0 |) in
                    let value_C := M.copy (| γ0_1 |) in
                    let value_B := M.copy (| γ0_2 |) in
                    let value_A := M.copy (| γ0_3 |) in
                    let value_Z := M.copy (| γ0_4 |) in
                    let value_Y := M.copy (| γ0_5 |) in
                    let value_X := M.copy (| γ0_6 |) in
                    let value_W := M.copy (| γ0_7 |) in
                    let value_V := M.copy (| γ0_8 |) in
                    let value_U := M.copy (| γ0_9 |) in
                    let value_T := M.copy (| γ0_10 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_D |);
                          M.read (| value_C |);
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 11 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_11_T_for_Tuple_T_T_T_T_T_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T_T_T__for_array_Usize_11_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 11 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_tuple_field (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_tuple_field (| γ, 8 |) in
                    let γ0_9 := M.SubPointer.get_tuple_field (| γ, 9 |) in
                    let γ0_10 := M.SubPointer.get_tuple_field (| γ, 10 |) in
                    let value_D := M.copy (| γ0_0 |) in
                    let value_C := M.copy (| γ0_1 |) in
                    let value_B := M.copy (| γ0_2 |) in
                    let value_A := M.copy (| γ0_3 |) in
                    let value_Z := M.copy (| γ0_4 |) in
                    let value_Y := M.copy (| γ0_5 |) in
                    let value_X := M.copy (| γ0_6 |) in
                    let value_W := M.copy (| γ0_7 |) in
                    let value_V := M.copy (| γ0_8 |) in
                    let value_U := M.copy (| γ0_9 |) in
                    let value_T := M.copy (| γ0_10 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_D |);
                          M.read (| value_C |);
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T_T_T__for_array_Usize_11_T.
  
  Module Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_E_where_core_cmp_PartialEq_D_where_core_cmp_PartialEq_C_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn eq(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} == other.${index()} )&&+
                    }
    *)
    Definition eq
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.and (|
            LogicalOp.and (|
              LogicalOp.and (|
                LogicalOp.and (|
                  LogicalOp.and (|
                    LogicalOp.and (|
                      LogicalOp.and (|
                        LogicalOp.and (|
                          LogicalOp.and (|
                            LogicalOp.and (|
                              LogicalOp.and (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    E,
                                    [ E ],
                                    "eq",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                                  ]
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      D,
                                      [ D ],
                                      "eq",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                      M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                                    ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    C,
                                    [ C ],
                                    "eq",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "eq", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "eq", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "eq", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "eq", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "eq", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "eq", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "eq", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 9 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 9 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "eq", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 10 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 10 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "eq", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 11 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 11 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ne(&self, other: &($($T,)+)) -> bool {
                        $( ${ignore($T)} self.${index()} != other.${index()} )||+
                    }
    *)
    Definition ne
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          LogicalOp.or (|
            LogicalOp.or (|
              LogicalOp.or (|
                LogicalOp.or (|
                  LogicalOp.or (|
                    LogicalOp.or (|
                      LogicalOp.or (|
                        LogicalOp.or (|
                          LogicalOp.or (|
                            LogicalOp.or (|
                              LogicalOp.or (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    E,
                                    [ E ],
                                    "ne",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                                  ]
                                |),
                                ltac:(M.monadic
                                  (M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      D,
                                      [ D ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                                      M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                                    ]
                                  |)))
                              |),
                              ltac:(M.monadic
                                (M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialEq",
                                    C,
                                    [ C ],
                                    "ne",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)))
                            |),
                            ltac:(M.monadic
                              (M.call_closure (|
                                M.get_trait_method (| "core::cmp::PartialEq", B, [ B ], "ne", [] |),
                                [
                                  M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                  M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                ]
                              |)))
                          |),
                          ltac:(M.monadic
                            (M.call_closure (|
                              M.get_trait_method (| "core::cmp::PartialEq", A, [ A ], "ne", [] |),
                              [
                                M.SubPointer.get_tuple_field (| M.read (| self |), 4 |);
                                M.SubPointer.get_tuple_field (| M.read (| other |), 4 |)
                              ]
                            |)))
                        |),
                        ltac:(M.monadic
                          (M.call_closure (|
                            M.get_trait_method (| "core::cmp::PartialEq", Z, [ Z ], "ne", [] |),
                            [
                              M.SubPointer.get_tuple_field (| M.read (| self |), 5 |);
                              M.SubPointer.get_tuple_field (| M.read (| other |), 5 |)
                            ]
                          |)))
                      |),
                      ltac:(M.monadic
                        (M.call_closure (|
                          M.get_trait_method (| "core::cmp::PartialEq", Y, [ Y ], "ne", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 6 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 6 |)
                          ]
                        |)))
                    |),
                    ltac:(M.monadic
                      (M.call_closure (|
                        M.get_trait_method (| "core::cmp::PartialEq", X, [ X ], "ne", [] |),
                        [
                          M.SubPointer.get_tuple_field (| M.read (| self |), 7 |);
                          M.SubPointer.get_tuple_field (| M.read (| other |), 7 |)
                        ]
                      |)))
                  |),
                  ltac:(M.monadic
                    (M.call_closure (|
                      M.get_trait_method (| "core::cmp::PartialEq", W, [ W ], "ne", [] |),
                      [
                        M.SubPointer.get_tuple_field (| M.read (| self |), 8 |);
                        M.SubPointer.get_tuple_field (| M.read (| other |), 8 |)
                      ]
                    |)))
                |),
                ltac:(M.monadic
                  (M.call_closure (|
                    M.get_trait_method (| "core::cmp::PartialEq", V, [ V ], "ne", [] |),
                    [
                      M.SubPointer.get_tuple_field (| M.read (| self |), 9 |);
                      M.SubPointer.get_tuple_field (| M.read (| other |), 9 |)
                    ]
                  |)))
              |),
              ltac:(M.monadic
                (M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialEq", U, [ U ], "ne", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 10 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 10 |)
                  ]
                |)))
            |),
            ltac:(M.monadic
              (M.call_closure (|
                M.get_trait_method (| "core::cmp::PartialEq", T, [ T ], "ne", [] |),
                [
                  M.SubPointer.get_tuple_field (| M.read (| self |), 11 |);
                  M.SubPointer.get_tuple_field (| M.read (| other |), 11 |)
                ]
              |)))
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialEq"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("eq", InstanceField.Method (eq E D C B A Z Y X W V U T));
          ("ne", InstanceField.Method (ne E D C B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialEq_where_core_cmp_PartialEq_E_where_core_cmp_PartialEq_D_where_core_cmp_PartialEq_C_where_core_cmp_PartialEq_B_where_core_cmp_PartialEq_A_where_core_cmp_PartialEq_Z_where_core_cmp_PartialEq_Y_where_core_cmp_PartialEq_X_where_core_cmp_PartialEq_W_where_core_cmp_PartialEq_V_where_core_cmp_PartialEq_U_where_core_cmp_PartialEq_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Eq_where_core_cmp_Eq_E_where_core_cmp_Eq_D_where_core_cmp_Eq_C_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Eq"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_cmp_Eq_where_core_cmp_Eq_E_where_core_cmp_Eq_D_where_core_cmp_Eq_C_where_core_cmp_Eq_B_where_core_cmp_Eq_A_where_core_cmp_Eq_Z_where_core_cmp_Eq_Y_where_core_cmp_Eq_X_where_core_cmp_Eq_W_where_core_cmp_Eq_V_where_core_cmp_Eq_U_where_core_cmp_Eq_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__E_where_core_marker_ConstParamTy__D_where_core_marker_ConstParamTy__C_where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::ConstParamTy_"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_ConstParamTy__where_core_marker_ConstParamTy__E_where_core_marker_ConstParamTy__D_where_core_marker_ConstParamTy__C_where_core_marker_ConstParamTy__B_where_core_marker_ConstParamTy__A_where_core_marker_ConstParamTy__Z_where_core_marker_ConstParamTy__Y_where_core_marker_ConstParamTy__X_where_core_marker_ConstParamTy__W_where_core_marker_ConstParamTy__V_where_core_marker_ConstParamTy__U_where_core_marker_ConstParamTy__T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_E_where_core_marker_UnsizedConstParamTy_D_where_core_marker_UnsizedConstParamTy_C_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::UnsizedConstParamTy"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_UnsizedConstParamTy_where_core_marker_UnsizedConstParamTy_E_where_core_marker_UnsizedConstParamTy_D_where_core_marker_UnsizedConstParamTy_C_where_core_marker_UnsizedConstParamTy_B_where_core_marker_UnsizedConstParamTy_A_where_core_marker_UnsizedConstParamTy_Z_where_core_marker_UnsizedConstParamTy_Y_where_core_marker_UnsizedConstParamTy_X_where_core_marker_UnsizedConstParamTy_W_where_core_marker_UnsizedConstParamTy_V_where_core_marker_UnsizedConstParamTy_U_where_core_marker_UnsizedConstParamTy_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_marker_StructuralPartialEq_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::marker::StructuralPartialEq"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [].
  End Impl_core_marker_StructuralPartialEq_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_E_where_core_cmp_PartialOrd_D_where_core_cmp_PartialOrd_C_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn partial_cmp(&self, other: &($($T,)+)) -> Option<Ordering> {
                        lexical_partial_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition partial_cmp
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", E, [ E ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 :=
                      M.SubPointer.get_struct_tuple_field (|
                        γ,
                        "core::option::Option::Some",
                        0
                      |) in
                    let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            D,
                            [ D ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ0_0 :=
                              M.SubPointer.get_struct_tuple_field (|
                                γ,
                                "core::option::Option::Some",
                                0
                              |) in
                            let _ := M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    C,
                                    [ C ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ0_0 :=
                                      M.SubPointer.get_struct_tuple_field (|
                                        γ,
                                        "core::option::Option::Some",
                                        0
                                      |) in
                                    let _ :=
                                      M.is_struct_tuple (| γ0_0, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            B,
                                            [ B ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ0_0 :=
                                              M.SubPointer.get_struct_tuple_field (|
                                                γ,
                                                "core::option::Option::Some",
                                                0
                                              |) in
                                            let _ :=
                                              M.is_struct_tuple (|
                                                γ0_0,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    A,
                                                    [ A ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ0_0 :=
                                                      M.SubPointer.get_struct_tuple_field (|
                                                        γ,
                                                        "core::option::Option::Some",
                                                        0
                                                      |) in
                                                    let _ :=
                                                      M.is_struct_tuple (|
                                                        γ0_0,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Z,
                                                            [ Z ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ0_0 :=
                                                              M.SubPointer.get_struct_tuple_field (|
                                                                γ,
                                                                "core::option::Option::Some",
                                                                0
                                                              |) in
                                                            let _ :=
                                                              M.is_struct_tuple (|
                                                                γ0_0,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    Y,
                                                                    [ Y ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ0_0 :=
                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                        γ,
                                                                        "core::option::Option::Some",
                                                                        0
                                                                      |) in
                                                                    let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ0_0,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            X,
                                                                            [ X ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ0_0 :=
                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                γ,
                                                                                "core::option::Option::Some",
                                                                                0
                                                                              |) in
                                                                            let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ0_0,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    W,
                                                                                    [ W ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ0_0 :=
                                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                                        γ,
                                                                                        "core::option::Option::Some",
                                                                                        0
                                                                                      |) in
                                                                                    let _ :=
                                                                                      M.is_struct_tuple (|
                                                                                        γ0_0,
                                                                                        "core::cmp::Ordering::Equal"
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            V,
                                                                                            [ V ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ0_0 :=
                                                                                              M.SubPointer.get_struct_tuple_field (|
                                                                                                γ,
                                                                                                "core::option::Option::Some",
                                                                                                0
                                                                                              |) in
                                                                                            let _ :=
                                                                                              M.is_struct_tuple (|
                                                                                                γ0_0,
                                                                                                "core::cmp::Ordering::Equal"
                                                                                              |) in
                                                                                            M.match_operator (|
                                                                                              M.alloc (|
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "core::cmp::PartialOrd",
                                                                                                    U,
                                                                                                    [
                                                                                                      U
                                                                                                    ],
                                                                                                    "partial_cmp",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        self
                                                                                                      |),
                                                                                                      10
                                                                                                    |);
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        other
                                                                                                      |),
                                                                                                      10
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              |),
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          γ0_0 :=
                                                                                                      M.SubPointer.get_struct_tuple_field (|
                                                                                                        γ,
                                                                                                        "core::option::Option::Some",
                                                                                                        0
                                                                                                      |) in
                                                                                                    let
                                                                                                          _ :=
                                                                                                      M.is_struct_tuple (|
                                                                                                        γ0_0,
                                                                                                        "core::cmp::Ordering::Equal"
                                                                                                      |) in
                                                                                                    M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialOrd",
                                                                                                          T,
                                                                                                          [
                                                                                                            T
                                                                                                          ],
                                                                                                          "partial_cmp",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              self
                                                                                                            |),
                                                                                                            11
                                                                                                          |);
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              other
                                                                                                            |),
                                                                                                            11
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)));
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          ordering :=
                                                                                                      M.copy (|
                                                                                                        γ
                                                                                                      |) in
                                                                                                    ordering))
                                                                                              ]
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  ordering :=
                                                                                              M.copy (|
                                                                                                γ
                                                                                              |) in
                                                                                            ordering))
                                                                                      ]
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let ordering :=
                                                                                      M.copy (|
                                                                                        γ
                                                                                      |) in
                                                                                    ordering))
                                                                              ]
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn lt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(lt, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition lt
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", E, [ E ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            D,
                            [ D ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    C,
                                    [ C ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            B,
                                            [ B ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    A,
                                                    [ A ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Z,
                                                            [ Z ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    Y,
                                                                    [ Y ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            X,
                                                                            [ X ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    W,
                                                                                    [ W ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Less"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            V,
                                                                                            [ V ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Less"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let~
                                                                                                  c :=
                                                                                              M.alloc (|
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "core::cmp::PartialOrd",
                                                                                                    U,
                                                                                                    [
                                                                                                      U
                                                                                                    ],
                                                                                                    "partial_cmp",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        self
                                                                                                      |),
                                                                                                      10
                                                                                                    |);
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        other
                                                                                                      |),
                                                                                                      10
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              |) in
                                                                                            M.match_operator (|
                                                                                              M.alloc (|
                                                                                                Value.Tuple
                                                                                                  []
                                                                                              |),
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          γ :=
                                                                                                      M.use
                                                                                                        (M.alloc (|
                                                                                                          M.call_closure (|
                                                                                                            M.get_trait_method (|
                                                                                                              "core::cmp::PartialEq",
                                                                                                              Ty.apply
                                                                                                                (Ty.path
                                                                                                                  "core::option::Option")
                                                                                                                []
                                                                                                                [
                                                                                                                  Ty.path
                                                                                                                    "core::cmp::Ordering"
                                                                                                                ],
                                                                                                              [
                                                                                                                Ty.apply
                                                                                                                  (Ty.path
                                                                                                                    "core::option::Option")
                                                                                                                  []
                                                                                                                  [
                                                                                                                    Ty.path
                                                                                                                      "core::cmp::Ordering"
                                                                                                                  ]
                                                                                                              ],
                                                                                                              "ne",
                                                                                                              []
                                                                                                            |),
                                                                                                            [
                                                                                                              c;
                                                                                                              M.alloc (|
                                                                                                                Value.StructTuple
                                                                                                                  "core::option::Option::Some"
                                                                                                                  [
                                                                                                                    Value.StructTuple
                                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                                      []
                                                                                                                  ]
                                                                                                              |)
                                                                                                            ]
                                                                                                          |)
                                                                                                        |)) in
                                                                                                    let
                                                                                                          _ :=
                                                                                                      M.is_constant_or_break_match (|
                                                                                                        M.read (|
                                                                                                          γ
                                                                                                        |),
                                                                                                        Value.Bool
                                                                                                          true
                                                                                                      |) in
                                                                                                    M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialEq",
                                                                                                          Ty.apply
                                                                                                            (Ty.path
                                                                                                              "core::option::Option")
                                                                                                            []
                                                                                                            [
                                                                                                              Ty.path
                                                                                                                "core::cmp::Ordering"
                                                                                                            ],
                                                                                                          [
                                                                                                            Ty.apply
                                                                                                              (Ty.path
                                                                                                                "core::option::Option")
                                                                                                              []
                                                                                                              [
                                                                                                                Ty.path
                                                                                                                  "core::cmp::Ordering"
                                                                                                              ]
                                                                                                          ],
                                                                                                          "eq",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          c;
                                                                                                          M.alloc (|
                                                                                                            Value.StructTuple
                                                                                                              "core::option::Option::Some"
                                                                                                              [
                                                                                                                Value.StructTuple
                                                                                                                  "core::cmp::Ordering::Less"
                                                                                                                  []
                                                                                                              ]
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)));
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialOrd",
                                                                                                          T,
                                                                                                          [
                                                                                                            T
                                                                                                          ],
                                                                                                          "lt",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              self
                                                                                                            |),
                                                                                                            11
                                                                                                          |);
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              other
                                                                                                            |),
                                                                                                            11
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)))
                                                                                              ]
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn le(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(le, Less, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition le
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", E, [ E ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            D,
                            [ D ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    C,
                                    [ C ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Less" [] ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            B,
                                            [ B ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Less"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    A,
                                                    [ A ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Less"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Z,
                                                            [ Z ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Less"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    Y,
                                                                    [ Y ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Less"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            X,
                                                                            [ X ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Less"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    W,
                                                                                    [ W ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Less"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            V,
                                                                                            [ V ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Less"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let~
                                                                                                  c :=
                                                                                              M.alloc (|
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "core::cmp::PartialOrd",
                                                                                                    U,
                                                                                                    [
                                                                                                      U
                                                                                                    ],
                                                                                                    "partial_cmp",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        self
                                                                                                      |),
                                                                                                      10
                                                                                                    |);
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        other
                                                                                                      |),
                                                                                                      10
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              |) in
                                                                                            M.match_operator (|
                                                                                              M.alloc (|
                                                                                                Value.Tuple
                                                                                                  []
                                                                                              |),
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          γ :=
                                                                                                      M.use
                                                                                                        (M.alloc (|
                                                                                                          M.call_closure (|
                                                                                                            M.get_trait_method (|
                                                                                                              "core::cmp::PartialEq",
                                                                                                              Ty.apply
                                                                                                                (Ty.path
                                                                                                                  "core::option::Option")
                                                                                                                []
                                                                                                                [
                                                                                                                  Ty.path
                                                                                                                    "core::cmp::Ordering"
                                                                                                                ],
                                                                                                              [
                                                                                                                Ty.apply
                                                                                                                  (Ty.path
                                                                                                                    "core::option::Option")
                                                                                                                  []
                                                                                                                  [
                                                                                                                    Ty.path
                                                                                                                      "core::cmp::Ordering"
                                                                                                                  ]
                                                                                                              ],
                                                                                                              "ne",
                                                                                                              []
                                                                                                            |),
                                                                                                            [
                                                                                                              c;
                                                                                                              M.alloc (|
                                                                                                                Value.StructTuple
                                                                                                                  "core::option::Option::Some"
                                                                                                                  [
                                                                                                                    Value.StructTuple
                                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                                      []
                                                                                                                  ]
                                                                                                              |)
                                                                                                            ]
                                                                                                          |)
                                                                                                        |)) in
                                                                                                    let
                                                                                                          _ :=
                                                                                                      M.is_constant_or_break_match (|
                                                                                                        M.read (|
                                                                                                          γ
                                                                                                        |),
                                                                                                        Value.Bool
                                                                                                          true
                                                                                                      |) in
                                                                                                    M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialEq",
                                                                                                          Ty.apply
                                                                                                            (Ty.path
                                                                                                              "core::option::Option")
                                                                                                            []
                                                                                                            [
                                                                                                              Ty.path
                                                                                                                "core::cmp::Ordering"
                                                                                                            ],
                                                                                                          [
                                                                                                            Ty.apply
                                                                                                              (Ty.path
                                                                                                                "core::option::Option")
                                                                                                              []
                                                                                                              [
                                                                                                                Ty.path
                                                                                                                  "core::cmp::Ordering"
                                                                                                              ]
                                                                                                          ],
                                                                                                          "eq",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          c;
                                                                                                          M.alloc (|
                                                                                                            Value.StructTuple
                                                                                                              "core::option::Option::Some"
                                                                                                              [
                                                                                                                Value.StructTuple
                                                                                                                  "core::cmp::Ordering::Less"
                                                                                                                  []
                                                                                                              ]
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)));
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialOrd",
                                                                                                          T,
                                                                                                          [
                                                                                                            T
                                                                                                          ],
                                                                                                          "le",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              self
                                                                                                            |),
                                                                                                            11
                                                                                                          |);
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              other
                                                                                                            |),
                                                                                                            11
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)))
                                                                                              ]
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn ge(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(ge, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition ge
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", E, [ E ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            D,
                            [ D ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    C,
                                    [ C ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            B,
                                            [ B ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    A,
                                                    [ A ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Z,
                                                            [ Z ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    Y,
                                                                    [ Y ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            X,
                                                                            [ X ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    W,
                                                                                    [ W ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            V,
                                                                                            [ V ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Greater"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let~
                                                                                                  c :=
                                                                                              M.alloc (|
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "core::cmp::PartialOrd",
                                                                                                    U,
                                                                                                    [
                                                                                                      U
                                                                                                    ],
                                                                                                    "partial_cmp",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        self
                                                                                                      |),
                                                                                                      10
                                                                                                    |);
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        other
                                                                                                      |),
                                                                                                      10
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              |) in
                                                                                            M.match_operator (|
                                                                                              M.alloc (|
                                                                                                Value.Tuple
                                                                                                  []
                                                                                              |),
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          γ :=
                                                                                                      M.use
                                                                                                        (M.alloc (|
                                                                                                          M.call_closure (|
                                                                                                            M.get_trait_method (|
                                                                                                              "core::cmp::PartialEq",
                                                                                                              Ty.apply
                                                                                                                (Ty.path
                                                                                                                  "core::option::Option")
                                                                                                                []
                                                                                                                [
                                                                                                                  Ty.path
                                                                                                                    "core::cmp::Ordering"
                                                                                                                ],
                                                                                                              [
                                                                                                                Ty.apply
                                                                                                                  (Ty.path
                                                                                                                    "core::option::Option")
                                                                                                                  []
                                                                                                                  [
                                                                                                                    Ty.path
                                                                                                                      "core::cmp::Ordering"
                                                                                                                  ]
                                                                                                              ],
                                                                                                              "ne",
                                                                                                              []
                                                                                                            |),
                                                                                                            [
                                                                                                              c;
                                                                                                              M.alloc (|
                                                                                                                Value.StructTuple
                                                                                                                  "core::option::Option::Some"
                                                                                                                  [
                                                                                                                    Value.StructTuple
                                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                                      []
                                                                                                                  ]
                                                                                                              |)
                                                                                                            ]
                                                                                                          |)
                                                                                                        |)) in
                                                                                                    let
                                                                                                          _ :=
                                                                                                      M.is_constant_or_break_match (|
                                                                                                        M.read (|
                                                                                                          γ
                                                                                                        |),
                                                                                                        Value.Bool
                                                                                                          true
                                                                                                      |) in
                                                                                                    M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialEq",
                                                                                                          Ty.apply
                                                                                                            (Ty.path
                                                                                                              "core::option::Option")
                                                                                                            []
                                                                                                            [
                                                                                                              Ty.path
                                                                                                                "core::cmp::Ordering"
                                                                                                            ],
                                                                                                          [
                                                                                                            Ty.apply
                                                                                                              (Ty.path
                                                                                                                "core::option::Option")
                                                                                                              []
                                                                                                              [
                                                                                                                Ty.path
                                                                                                                  "core::cmp::Ordering"
                                                                                                              ]
                                                                                                          ],
                                                                                                          "eq",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          c;
                                                                                                          M.alloc (|
                                                                                                            Value.StructTuple
                                                                                                              "core::option::Option::Some"
                                                                                                              [
                                                                                                                Value.StructTuple
                                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                                  []
                                                                                                              ]
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)));
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialOrd",
                                                                                                          T,
                                                                                                          [
                                                                                                            T
                                                                                                          ],
                                                                                                          "ge",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              self
                                                                                                            |),
                                                                                                            11
                                                                                                          |);
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              other
                                                                                                            |),
                                                                                                            11
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)))
                                                                                              ]
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    (*
                    fn gt(&self, other: &($($T,)+)) -> bool {
                        lexical_ord!(gt, Greater, $( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition gt
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            let~ c :=
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::PartialOrd", E, [ E ], "partial_cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |) in
            M.match_operator (|
              M.alloc (| Value.Tuple [] |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ :=
                      M.use
                        (M.alloc (|
                          M.call_closure (|
                            M.get_trait_method (|
                              "core::cmp::PartialEq",
                              Ty.apply
                                (Ty.path "core::option::Option")
                                []
                                [ Ty.path "core::cmp::Ordering" ],
                              [
                                Ty.apply
                                  (Ty.path "core::option::Option")
                                  []
                                  [ Ty.path "core::cmp::Ordering" ]
                              ],
                              "ne",
                              []
                            |),
                            [
                              c;
                              M.alloc (|
                                Value.StructTuple
                                  "core::option::Option::Some"
                                  [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                              |)
                            ]
                          |)
                        |)) in
                    let _ := M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                    M.alloc (|
                      M.call_closure (|
                        M.get_trait_method (|
                          "core::cmp::PartialEq",
                          Ty.apply
                            (Ty.path "core::option::Option")
                            []
                            [ Ty.path "core::cmp::Ordering" ],
                          [
                            Ty.apply
                              (Ty.path "core::option::Option")
                              []
                              [ Ty.path "core::cmp::Ordering" ]
                          ],
                          "eq",
                          []
                        |),
                        [
                          c;
                          M.alloc (|
                            Value.StructTuple
                              "core::option::Option::Some"
                              [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                          |)
                        ]
                      |)
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let~ c :=
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (|
                            "core::cmp::PartialOrd",
                            D,
                            [ D ],
                            "partial_cmp",
                            []
                          |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |) in
                    M.match_operator (|
                      M.alloc (| Value.Tuple [] |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let γ :=
                              M.use
                                (M.alloc (|
                                  M.call_closure (|
                                    M.get_trait_method (|
                                      "core::cmp::PartialEq",
                                      Ty.apply
                                        (Ty.path "core::option::Option")
                                        []
                                        [ Ty.path "core::cmp::Ordering" ],
                                      [
                                        Ty.apply
                                          (Ty.path "core::option::Option")
                                          []
                                          [ Ty.path "core::cmp::Ordering" ]
                                      ],
                                      "ne",
                                      []
                                    |),
                                    [
                                      c;
                                      M.alloc (|
                                        Value.StructTuple
                                          "core::option::Option::Some"
                                          [ Value.StructTuple "core::cmp::Ordering::Equal" [] ]
                                      |)
                                    ]
                                  |)
                                |)) in
                            let _ :=
                              M.is_constant_or_break_match (| M.read (| γ |), Value.Bool true |) in
                            M.alloc (|
                              M.call_closure (|
                                M.get_trait_method (|
                                  "core::cmp::PartialEq",
                                  Ty.apply
                                    (Ty.path "core::option::Option")
                                    []
                                    [ Ty.path "core::cmp::Ordering" ],
                                  [
                                    Ty.apply
                                      (Ty.path "core::option::Option")
                                      []
                                      [ Ty.path "core::cmp::Ordering" ]
                                  ],
                                  "eq",
                                  []
                                |),
                                [
                                  c;
                                  M.alloc (|
                                    Value.StructTuple
                                      "core::option::Option::Some"
                                      [ Value.StructTuple "core::cmp::Ordering::Greater" [] ]
                                  |)
                                ]
                              |)
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let~ c :=
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (|
                                    "core::cmp::PartialOrd",
                                    C,
                                    [ C ],
                                    "partial_cmp",
                                    []
                                  |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |) in
                            M.match_operator (|
                              M.alloc (| Value.Tuple [] |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let γ :=
                                      M.use
                                        (M.alloc (|
                                          M.call_closure (|
                                            M.get_trait_method (|
                                              "core::cmp::PartialEq",
                                              Ty.apply
                                                (Ty.path "core::option::Option")
                                                []
                                                [ Ty.path "core::cmp::Ordering" ],
                                              [
                                                Ty.apply
                                                  (Ty.path "core::option::Option")
                                                  []
                                                  [ Ty.path "core::cmp::Ordering" ]
                                              ],
                                              "ne",
                                              []
                                            |),
                                            [
                                              c;
                                              M.alloc (|
                                                Value.StructTuple
                                                  "core::option::Option::Some"
                                                  [
                                                    Value.StructTuple
                                                      "core::cmp::Ordering::Equal"
                                                      []
                                                  ]
                                              |)
                                            ]
                                          |)
                                        |)) in
                                    let _ :=
                                      M.is_constant_or_break_match (|
                                        M.read (| γ |),
                                        Value.Bool true
                                      |) in
                                    M.alloc (|
                                      M.call_closure (|
                                        M.get_trait_method (|
                                          "core::cmp::PartialEq",
                                          Ty.apply
                                            (Ty.path "core::option::Option")
                                            []
                                            [ Ty.path "core::cmp::Ordering" ],
                                          [
                                            Ty.apply
                                              (Ty.path "core::option::Option")
                                              []
                                              [ Ty.path "core::cmp::Ordering" ]
                                          ],
                                          "eq",
                                          []
                                        |),
                                        [
                                          c;
                                          M.alloc (|
                                            Value.StructTuple
                                              "core::option::Option::Some"
                                              [ Value.StructTuple "core::cmp::Ordering::Greater" []
                                              ]
                                          |)
                                        ]
                                      |)
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let~ c :=
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::PartialOrd",
                                            B,
                                            [ B ],
                                            "partial_cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |) in
                                    M.match_operator (|
                                      M.alloc (| Value.Tuple [] |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let γ :=
                                              M.use
                                                (M.alloc (|
                                                  M.call_closure (|
                                                    M.get_trait_method (|
                                                      "core::cmp::PartialEq",
                                                      Ty.apply
                                                        (Ty.path "core::option::Option")
                                                        []
                                                        [ Ty.path "core::cmp::Ordering" ],
                                                      [
                                                        Ty.apply
                                                          (Ty.path "core::option::Option")
                                                          []
                                                          [ Ty.path "core::cmp::Ordering" ]
                                                      ],
                                                      "ne",
                                                      []
                                                    |),
                                                    [
                                                      c;
                                                      M.alloc (|
                                                        Value.StructTuple
                                                          "core::option::Option::Some"
                                                          [
                                                            Value.StructTuple
                                                              "core::cmp::Ordering::Equal"
                                                              []
                                                          ]
                                                      |)
                                                    ]
                                                  |)
                                                |)) in
                                            let _ :=
                                              M.is_constant_or_break_match (|
                                                M.read (| γ |),
                                                Value.Bool true
                                              |) in
                                            M.alloc (|
                                              M.call_closure (|
                                                M.get_trait_method (|
                                                  "core::cmp::PartialEq",
                                                  Ty.apply
                                                    (Ty.path "core::option::Option")
                                                    []
                                                    [ Ty.path "core::cmp::Ordering" ],
                                                  [
                                                    Ty.apply
                                                      (Ty.path "core::option::Option")
                                                      []
                                                      [ Ty.path "core::cmp::Ordering" ]
                                                  ],
                                                  "eq",
                                                  []
                                                |),
                                                [
                                                  c;
                                                  M.alloc (|
                                                    Value.StructTuple
                                                      "core::option::Option::Some"
                                                      [
                                                        Value.StructTuple
                                                          "core::cmp::Ordering::Greater"
                                                          []
                                                      ]
                                                  |)
                                                ]
                                              |)
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let~ c :=
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::PartialOrd",
                                                    A,
                                                    [ A ],
                                                    "partial_cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |) in
                                            M.match_operator (|
                                              M.alloc (| Value.Tuple [] |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let γ :=
                                                      M.use
                                                        (M.alloc (|
                                                          M.call_closure (|
                                                            M.get_trait_method (|
                                                              "core::cmp::PartialEq",
                                                              Ty.apply
                                                                (Ty.path "core::option::Option")
                                                                []
                                                                [ Ty.path "core::cmp::Ordering" ],
                                                              [
                                                                Ty.apply
                                                                  (Ty.path "core::option::Option")
                                                                  []
                                                                  [ Ty.path "core::cmp::Ordering" ]
                                                              ],
                                                              "ne",
                                                              []
                                                            |),
                                                            [
                                                              c;
                                                              M.alloc (|
                                                                Value.StructTuple
                                                                  "core::option::Option::Some"
                                                                  [
                                                                    Value.StructTuple
                                                                      "core::cmp::Ordering::Equal"
                                                                      []
                                                                  ]
                                                              |)
                                                            ]
                                                          |)
                                                        |)) in
                                                    let _ :=
                                                      M.is_constant_or_break_match (|
                                                        M.read (| γ |),
                                                        Value.Bool true
                                                      |) in
                                                    M.alloc (|
                                                      M.call_closure (|
                                                        M.get_trait_method (|
                                                          "core::cmp::PartialEq",
                                                          Ty.apply
                                                            (Ty.path "core::option::Option")
                                                            []
                                                            [ Ty.path "core::cmp::Ordering" ],
                                                          [
                                                            Ty.apply
                                                              (Ty.path "core::option::Option")
                                                              []
                                                              [ Ty.path "core::cmp::Ordering" ]
                                                          ],
                                                          "eq",
                                                          []
                                                        |),
                                                        [
                                                          c;
                                                          M.alloc (|
                                                            Value.StructTuple
                                                              "core::option::Option::Some"
                                                              [
                                                                Value.StructTuple
                                                                  "core::cmp::Ordering::Greater"
                                                                  []
                                                              ]
                                                          |)
                                                        ]
                                                      |)
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let~ c :=
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::PartialOrd",
                                                            Z,
                                                            [ Z ],
                                                            "partial_cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (| Value.Tuple [] |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let γ :=
                                                              M.use
                                                                (M.alloc (|
                                                                  M.call_closure (|
                                                                    M.get_trait_method (|
                                                                      "core::cmp::PartialEq",
                                                                      Ty.apply
                                                                        (Ty.path
                                                                          "core::option::Option")
                                                                        []
                                                                        [
                                                                          Ty.path
                                                                            "core::cmp::Ordering"
                                                                        ],
                                                                      [
                                                                        Ty.apply
                                                                          (Ty.path
                                                                            "core::option::Option")
                                                                          []
                                                                          [
                                                                            Ty.path
                                                                              "core::cmp::Ordering"
                                                                          ]
                                                                      ],
                                                                      "ne",
                                                                      []
                                                                    |),
                                                                    [
                                                                      c;
                                                                      M.alloc (|
                                                                        Value.StructTuple
                                                                          "core::option::Option::Some"
                                                                          [
                                                                            Value.StructTuple
                                                                              "core::cmp::Ordering::Equal"
                                                                              []
                                                                          ]
                                                                      |)
                                                                    ]
                                                                  |)
                                                                |)) in
                                                            let _ :=
                                                              M.is_constant_or_break_match (|
                                                                M.read (| γ |),
                                                                Value.Bool true
                                                              |) in
                                                            M.alloc (|
                                                              M.call_closure (|
                                                                M.get_trait_method (|
                                                                  "core::cmp::PartialEq",
                                                                  Ty.apply
                                                                    (Ty.path "core::option::Option")
                                                                    []
                                                                    [ Ty.path "core::cmp::Ordering"
                                                                    ],
                                                                  [
                                                                    Ty.apply
                                                                      (Ty.path
                                                                        "core::option::Option")
                                                                      []
                                                                      [
                                                                        Ty.path
                                                                          "core::cmp::Ordering"
                                                                      ]
                                                                  ],
                                                                  "eq",
                                                                  []
                                                                |),
                                                                [
                                                                  c;
                                                                  M.alloc (|
                                                                    Value.StructTuple
                                                                      "core::option::Option::Some"
                                                                      [
                                                                        Value.StructTuple
                                                                          "core::cmp::Ordering::Greater"
                                                                          []
                                                                      ]
                                                                  |)
                                                                ]
                                                              |)
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let~ c :=
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::PartialOrd",
                                                                    Y,
                                                                    [ Y ],
                                                                    "partial_cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (| Value.Tuple [] |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let γ :=
                                                                      M.use
                                                                        (M.alloc (|
                                                                          M.call_closure (|
                                                                            M.get_trait_method (|
                                                                              "core::cmp::PartialEq",
                                                                              Ty.apply
                                                                                (Ty.path
                                                                                  "core::option::Option")
                                                                                []
                                                                                [
                                                                                  Ty.path
                                                                                    "core::cmp::Ordering"
                                                                                ],
                                                                              [
                                                                                Ty.apply
                                                                                  (Ty.path
                                                                                    "core::option::Option")
                                                                                  []
                                                                                  [
                                                                                    Ty.path
                                                                                      "core::cmp::Ordering"
                                                                                  ]
                                                                              ],
                                                                              "ne",
                                                                              []
                                                                            |),
                                                                            [
                                                                              c;
                                                                              M.alloc (|
                                                                                Value.StructTuple
                                                                                  "core::option::Option::Some"
                                                                                  [
                                                                                    Value.StructTuple
                                                                                      "core::cmp::Ordering::Equal"
                                                                                      []
                                                                                  ]
                                                                              |)
                                                                            ]
                                                                          |)
                                                                        |)) in
                                                                    let _ :=
                                                                      M.is_constant_or_break_match (|
                                                                        M.read (| γ |),
                                                                        Value.Bool true
                                                                      |) in
                                                                    M.alloc (|
                                                                      M.call_closure (|
                                                                        M.get_trait_method (|
                                                                          "core::cmp::PartialEq",
                                                                          Ty.apply
                                                                            (Ty.path
                                                                              "core::option::Option")
                                                                            []
                                                                            [
                                                                              Ty.path
                                                                                "core::cmp::Ordering"
                                                                            ],
                                                                          [
                                                                            Ty.apply
                                                                              (Ty.path
                                                                                "core::option::Option")
                                                                              []
                                                                              [
                                                                                Ty.path
                                                                                  "core::cmp::Ordering"
                                                                              ]
                                                                          ],
                                                                          "eq",
                                                                          []
                                                                        |),
                                                                        [
                                                                          c;
                                                                          M.alloc (|
                                                                            Value.StructTuple
                                                                              "core::option::Option::Some"
                                                                              [
                                                                                Value.StructTuple
                                                                                  "core::cmp::Ordering::Greater"
                                                                                  []
                                                                              ]
                                                                          |)
                                                                        ]
                                                                      |)
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let~ c :=
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::PartialOrd",
                                                                            X,
                                                                            [ X ],
                                                                            "partial_cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (| Value.Tuple [] |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let γ :=
                                                                              M.use
                                                                                (M.alloc (|
                                                                                  M.call_closure (|
                                                                                    M.get_trait_method (|
                                                                                      "core::cmp::PartialEq",
                                                                                      Ty.apply
                                                                                        (Ty.path
                                                                                          "core::option::Option")
                                                                                        []
                                                                                        [
                                                                                          Ty.path
                                                                                            "core::cmp::Ordering"
                                                                                        ],
                                                                                      [
                                                                                        Ty.apply
                                                                                          (Ty.path
                                                                                            "core::option::Option")
                                                                                          []
                                                                                          [
                                                                                            Ty.path
                                                                                              "core::cmp::Ordering"
                                                                                          ]
                                                                                      ],
                                                                                      "ne",
                                                                                      []
                                                                                    |),
                                                                                    [
                                                                                      c;
                                                                                      M.alloc (|
                                                                                        Value.StructTuple
                                                                                          "core::option::Option::Some"
                                                                                          [
                                                                                            Value.StructTuple
                                                                                              "core::cmp::Ordering::Equal"
                                                                                              []
                                                                                          ]
                                                                                      |)
                                                                                    ]
                                                                                  |)
                                                                                |)) in
                                                                            let _ :=
                                                                              M.is_constant_or_break_match (|
                                                                                M.read (| γ |),
                                                                                Value.Bool true
                                                                              |) in
                                                                            M.alloc (|
                                                                              M.call_closure (|
                                                                                M.get_trait_method (|
                                                                                  "core::cmp::PartialEq",
                                                                                  Ty.apply
                                                                                    (Ty.path
                                                                                      "core::option::Option")
                                                                                    []
                                                                                    [
                                                                                      Ty.path
                                                                                        "core::cmp::Ordering"
                                                                                    ],
                                                                                  [
                                                                                    Ty.apply
                                                                                      (Ty.path
                                                                                        "core::option::Option")
                                                                                      []
                                                                                      [
                                                                                        Ty.path
                                                                                          "core::cmp::Ordering"
                                                                                      ]
                                                                                  ],
                                                                                  "eq",
                                                                                  []
                                                                                |),
                                                                                [
                                                                                  c;
                                                                                  M.alloc (|
                                                                                    Value.StructTuple
                                                                                      "core::option::Option::Some"
                                                                                      [
                                                                                        Value.StructTuple
                                                                                          "core::cmp::Ordering::Greater"
                                                                                          []
                                                                                      ]
                                                                                  |)
                                                                                ]
                                                                              |)
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let~ c :=
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::PartialOrd",
                                                                                    W,
                                                                                    [ W ],
                                                                                    "partial_cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                Value.Tuple []
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let γ :=
                                                                                      M.use
                                                                                        (M.alloc (|
                                                                                          M.call_closure (|
                                                                                            M.get_trait_method (|
                                                                                              "core::cmp::PartialEq",
                                                                                              Ty.apply
                                                                                                (Ty.path
                                                                                                  "core::option::Option")
                                                                                                []
                                                                                                [
                                                                                                  Ty.path
                                                                                                    "core::cmp::Ordering"
                                                                                                ],
                                                                                              [
                                                                                                Ty.apply
                                                                                                  (Ty.path
                                                                                                    "core::option::Option")
                                                                                                  []
                                                                                                  [
                                                                                                    Ty.path
                                                                                                      "core::cmp::Ordering"
                                                                                                  ]
                                                                                              ],
                                                                                              "ne",
                                                                                              []
                                                                                            |),
                                                                                            [
                                                                                              c;
                                                                                              M.alloc (|
                                                                                                Value.StructTuple
                                                                                                  "core::option::Option::Some"
                                                                                                  [
                                                                                                    Value.StructTuple
                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                      []
                                                                                                  ]
                                                                                              |)
                                                                                            ]
                                                                                          |)
                                                                                        |)) in
                                                                                    let _ :=
                                                                                      M.is_constant_or_break_match (|
                                                                                        M.read (|
                                                                                          γ
                                                                                        |),
                                                                                        Value.Bool
                                                                                          true
                                                                                      |) in
                                                                                    M.alloc (|
                                                                                      M.call_closure (|
                                                                                        M.get_trait_method (|
                                                                                          "core::cmp::PartialEq",
                                                                                          Ty.apply
                                                                                            (Ty.path
                                                                                              "core::option::Option")
                                                                                            []
                                                                                            [
                                                                                              Ty.path
                                                                                                "core::cmp::Ordering"
                                                                                            ],
                                                                                          [
                                                                                            Ty.apply
                                                                                              (Ty.path
                                                                                                "core::option::Option")
                                                                                              []
                                                                                              [
                                                                                                Ty.path
                                                                                                  "core::cmp::Ordering"
                                                                                              ]
                                                                                          ],
                                                                                          "eq",
                                                                                          []
                                                                                        |),
                                                                                        [
                                                                                          c;
                                                                                          M.alloc (|
                                                                                            Value.StructTuple
                                                                                              "core::option::Option::Some"
                                                                                              [
                                                                                                Value.StructTuple
                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                  []
                                                                                              ]
                                                                                          |)
                                                                                        ]
                                                                                      |)
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let~ c :=
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::PartialOrd",
                                                                                            V,
                                                                                            [ V ],
                                                                                            "partial_cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        Value.Tuple
                                                                                          []
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  γ :=
                                                                                              M.use
                                                                                                (M.alloc (|
                                                                                                  M.call_closure (|
                                                                                                    M.get_trait_method (|
                                                                                                      "core::cmp::PartialEq",
                                                                                                      Ty.apply
                                                                                                        (Ty.path
                                                                                                          "core::option::Option")
                                                                                                        []
                                                                                                        [
                                                                                                          Ty.path
                                                                                                            "core::cmp::Ordering"
                                                                                                        ],
                                                                                                      [
                                                                                                        Ty.apply
                                                                                                          (Ty.path
                                                                                                            "core::option::Option")
                                                                                                          []
                                                                                                          [
                                                                                                            Ty.path
                                                                                                              "core::cmp::Ordering"
                                                                                                          ]
                                                                                                      ],
                                                                                                      "ne",
                                                                                                      []
                                                                                                    |),
                                                                                                    [
                                                                                                      c;
                                                                                                      M.alloc (|
                                                                                                        Value.StructTuple
                                                                                                          "core::option::Option::Some"
                                                                                                          [
                                                                                                            Value.StructTuple
                                                                                                              "core::cmp::Ordering::Equal"
                                                                                                              []
                                                                                                          ]
                                                                                                      |)
                                                                                                    ]
                                                                                                  |)
                                                                                                |)) in
                                                                                            let _ :=
                                                                                              M.is_constant_or_break_match (|
                                                                                                M.read (|
                                                                                                  γ
                                                                                                |),
                                                                                                Value.Bool
                                                                                                  true
                                                                                              |) in
                                                                                            M.alloc (|
                                                                                              M.call_closure (|
                                                                                                M.get_trait_method (|
                                                                                                  "core::cmp::PartialEq",
                                                                                                  Ty.apply
                                                                                                    (Ty.path
                                                                                                      "core::option::Option")
                                                                                                    []
                                                                                                    [
                                                                                                      Ty.path
                                                                                                        "core::cmp::Ordering"
                                                                                                    ],
                                                                                                  [
                                                                                                    Ty.apply
                                                                                                      (Ty.path
                                                                                                        "core::option::Option")
                                                                                                      []
                                                                                                      [
                                                                                                        Ty.path
                                                                                                          "core::cmp::Ordering"
                                                                                                      ]
                                                                                                  ],
                                                                                                  "eq",
                                                                                                  []
                                                                                                |),
                                                                                                [
                                                                                                  c;
                                                                                                  M.alloc (|
                                                                                                    Value.StructTuple
                                                                                                      "core::option::Option::Some"
                                                                                                      [
                                                                                                        Value.StructTuple
                                                                                                          "core::cmp::Ordering::Greater"
                                                                                                          []
                                                                                                      ]
                                                                                                  |)
                                                                                                ]
                                                                                              |)
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let~
                                                                                                  c :=
                                                                                              M.alloc (|
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "core::cmp::PartialOrd",
                                                                                                    U,
                                                                                                    [
                                                                                                      U
                                                                                                    ],
                                                                                                    "partial_cmp",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        self
                                                                                                      |),
                                                                                                      10
                                                                                                    |);
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        other
                                                                                                      |),
                                                                                                      10
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              |) in
                                                                                            M.match_operator (|
                                                                                              M.alloc (|
                                                                                                Value.Tuple
                                                                                                  []
                                                                                              |),
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          γ :=
                                                                                                      M.use
                                                                                                        (M.alloc (|
                                                                                                          M.call_closure (|
                                                                                                            M.get_trait_method (|
                                                                                                              "core::cmp::PartialEq",
                                                                                                              Ty.apply
                                                                                                                (Ty.path
                                                                                                                  "core::option::Option")
                                                                                                                []
                                                                                                                [
                                                                                                                  Ty.path
                                                                                                                    "core::cmp::Ordering"
                                                                                                                ],
                                                                                                              [
                                                                                                                Ty.apply
                                                                                                                  (Ty.path
                                                                                                                    "core::option::Option")
                                                                                                                  []
                                                                                                                  [
                                                                                                                    Ty.path
                                                                                                                      "core::cmp::Ordering"
                                                                                                                  ]
                                                                                                              ],
                                                                                                              "ne",
                                                                                                              []
                                                                                                            |),
                                                                                                            [
                                                                                                              c;
                                                                                                              M.alloc (|
                                                                                                                Value.StructTuple
                                                                                                                  "core::option::Option::Some"
                                                                                                                  [
                                                                                                                    Value.StructTuple
                                                                                                                      "core::cmp::Ordering::Equal"
                                                                                                                      []
                                                                                                                  ]
                                                                                                              |)
                                                                                                            ]
                                                                                                          |)
                                                                                                        |)) in
                                                                                                    let
                                                                                                          _ :=
                                                                                                      M.is_constant_or_break_match (|
                                                                                                        M.read (|
                                                                                                          γ
                                                                                                        |),
                                                                                                        Value.Bool
                                                                                                          true
                                                                                                      |) in
                                                                                                    M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialEq",
                                                                                                          Ty.apply
                                                                                                            (Ty.path
                                                                                                              "core::option::Option")
                                                                                                            []
                                                                                                            [
                                                                                                              Ty.path
                                                                                                                "core::cmp::Ordering"
                                                                                                            ],
                                                                                                          [
                                                                                                            Ty.apply
                                                                                                              (Ty.path
                                                                                                                "core::option::Option")
                                                                                                              []
                                                                                                              [
                                                                                                                Ty.path
                                                                                                                  "core::cmp::Ordering"
                                                                                                              ]
                                                                                                          ],
                                                                                                          "eq",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          c;
                                                                                                          M.alloc (|
                                                                                                            Value.StructTuple
                                                                                                              "core::option::Option::Some"
                                                                                                              [
                                                                                                                Value.StructTuple
                                                                                                                  "core::cmp::Ordering::Greater"
                                                                                                                  []
                                                                                                              ]
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)));
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::PartialOrd",
                                                                                                          T,
                                                                                                          [
                                                                                                            T
                                                                                                          ],
                                                                                                          "gt",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              self
                                                                                                            |),
                                                                                                            11
                                                                                                          |);
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              other
                                                                                                            |),
                                                                                                            11
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)))
                                                                                              ]
                                                                                            |)))
                                                                                      ]
                                                                                    |)))
                                                                              ]
                                                                            |)))
                                                                      ]
                                                                    |)))
                                                              ]
                                                            |)))
                                                      ]
                                                    |)))
                                              ]
                                            |)))
                                      ]
                                    |)))
                              ]
                            |)))
                      ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::PartialOrd"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *)
        [
          ("partial_cmp", InstanceField.Method (partial_cmp E D C B A Z Y X W V U T));
          ("lt", InstanceField.Method (lt E D C B A Z Y X W V U T));
          ("le", InstanceField.Method (le E D C B A Z Y X W V U T));
          ("ge", InstanceField.Method (ge E D C B A Z Y X W V U T));
          ("gt", InstanceField.Method (gt E D C B A Z Y X W V U T))
        ].
  End Impl_core_cmp_PartialOrd_where_core_cmp_PartialOrd_E_where_core_cmp_PartialOrd_D_where_core_cmp_PartialOrd_C_where_core_cmp_PartialOrd_B_where_core_cmp_PartialOrd_A_where_core_cmp_PartialOrd_Z_where_core_cmp_PartialOrd_Y_where_core_cmp_PartialOrd_X_where_core_cmp_PartialOrd_W_where_core_cmp_PartialOrd_V_where_core_cmp_PartialOrd_U_where_core_cmp_PartialOrd_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_cmp_Ord_where_core_cmp_Ord_E_where_core_cmp_Ord_D_where_core_cmp_Ord_C_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn cmp(&self, other: &($($T,)+)) -> Ordering {
                        lexical_cmp!($( ${ignore($T)} self.${index()}, other.${index()} ),+)
                    }
    *)
    Definition cmp
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [ self; other ] =>
        ltac:(M.monadic
          (let self := M.alloc (| self |) in
          let other := M.alloc (| other |) in
          M.read (|
            M.match_operator (|
              M.alloc (|
                M.call_closure (|
                  M.get_trait_method (| "core::cmp::Ord", E, [], "cmp", [] |),
                  [
                    M.SubPointer.get_tuple_field (| M.read (| self |), 0 |);
                    M.SubPointer.get_tuple_field (| M.read (| other |), 0 |)
                  ]
                |)
              |),
              [
                fun γ =>
                  ltac:(M.monadic
                    (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                    M.match_operator (|
                      M.alloc (|
                        M.call_closure (|
                          M.get_trait_method (| "core::cmp::Ord", D, [], "cmp", [] |),
                          [
                            M.SubPointer.get_tuple_field (| M.read (| self |), 1 |);
                            M.SubPointer.get_tuple_field (| M.read (| other |), 1 |)
                          ]
                        |)
                      |),
                      [
                        fun γ =>
                          ltac:(M.monadic
                            (let _ := M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                            M.match_operator (|
                              M.alloc (|
                                M.call_closure (|
                                  M.get_trait_method (| "core::cmp::Ord", C, [], "cmp", [] |),
                                  [
                                    M.SubPointer.get_tuple_field (| M.read (| self |), 2 |);
                                    M.SubPointer.get_tuple_field (| M.read (| other |), 2 |)
                                  ]
                                |)
                              |),
                              [
                                fun γ =>
                                  ltac:(M.monadic
                                    (let _ :=
                                      M.is_struct_tuple (| γ, "core::cmp::Ordering::Equal" |) in
                                    M.match_operator (|
                                      M.alloc (|
                                        M.call_closure (|
                                          M.get_trait_method (|
                                            "core::cmp::Ord",
                                            B,
                                            [],
                                            "cmp",
                                            []
                                          |),
                                          [
                                            M.SubPointer.get_tuple_field (| M.read (| self |), 3 |);
                                            M.SubPointer.get_tuple_field (| M.read (| other |), 3 |)
                                          ]
                                        |)
                                      |),
                                      [
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let _ :=
                                              M.is_struct_tuple (|
                                                γ,
                                                "core::cmp::Ordering::Equal"
                                              |) in
                                            M.match_operator (|
                                              M.alloc (|
                                                M.call_closure (|
                                                  M.get_trait_method (|
                                                    "core::cmp::Ord",
                                                    A,
                                                    [],
                                                    "cmp",
                                                    []
                                                  |),
                                                  [
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| self |),
                                                      4
                                                    |);
                                                    M.SubPointer.get_tuple_field (|
                                                      M.read (| other |),
                                                      4
                                                    |)
                                                  ]
                                                |)
                                              |),
                                              [
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let _ :=
                                                      M.is_struct_tuple (|
                                                        γ,
                                                        "core::cmp::Ordering::Equal"
                                                      |) in
                                                    M.match_operator (|
                                                      M.alloc (|
                                                        M.call_closure (|
                                                          M.get_trait_method (|
                                                            "core::cmp::Ord",
                                                            Z,
                                                            [],
                                                            "cmp",
                                                            []
                                                          |),
                                                          [
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| self |),
                                                              5
                                                            |);
                                                            M.SubPointer.get_tuple_field (|
                                                              M.read (| other |),
                                                              5
                                                            |)
                                                          ]
                                                        |)
                                                      |),
                                                      [
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let _ :=
                                                              M.is_struct_tuple (|
                                                                γ,
                                                                "core::cmp::Ordering::Equal"
                                                              |) in
                                                            M.match_operator (|
                                                              M.alloc (|
                                                                M.call_closure (|
                                                                  M.get_trait_method (|
                                                                    "core::cmp::Ord",
                                                                    Y,
                                                                    [],
                                                                    "cmp",
                                                                    []
                                                                  |),
                                                                  [
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| self |),
                                                                      6
                                                                    |);
                                                                    M.SubPointer.get_tuple_field (|
                                                                      M.read (| other |),
                                                                      6
                                                                    |)
                                                                  ]
                                                                |)
                                                              |),
                                                              [
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let _ :=
                                                                      M.is_struct_tuple (|
                                                                        γ,
                                                                        "core::cmp::Ordering::Equal"
                                                                      |) in
                                                                    M.match_operator (|
                                                                      M.alloc (|
                                                                        M.call_closure (|
                                                                          M.get_trait_method (|
                                                                            "core::cmp::Ord",
                                                                            X,
                                                                            [],
                                                                            "cmp",
                                                                            []
                                                                          |),
                                                                          [
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| self |),
                                                                              7
                                                                            |);
                                                                            M.SubPointer.get_tuple_field (|
                                                                              M.read (| other |),
                                                                              7
                                                                            |)
                                                                          ]
                                                                        |)
                                                                      |),
                                                                      [
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let _ :=
                                                                              M.is_struct_tuple (|
                                                                                γ,
                                                                                "core::cmp::Ordering::Equal"
                                                                              |) in
                                                                            M.match_operator (|
                                                                              M.alloc (|
                                                                                M.call_closure (|
                                                                                  M.get_trait_method (|
                                                                                    "core::cmp::Ord",
                                                                                    W,
                                                                                    [],
                                                                                    "cmp",
                                                                                    []
                                                                                  |),
                                                                                  [
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        self
                                                                                      |),
                                                                                      8
                                                                                    |);
                                                                                    M.SubPointer.get_tuple_field (|
                                                                                      M.read (|
                                                                                        other
                                                                                      |),
                                                                                      8
                                                                                    |)
                                                                                  ]
                                                                                |)
                                                                              |),
                                                                              [
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let _ :=
                                                                                      M.is_struct_tuple (|
                                                                                        γ,
                                                                                        "core::cmp::Ordering::Equal"
                                                                                      |) in
                                                                                    M.match_operator (|
                                                                                      M.alloc (|
                                                                                        M.call_closure (|
                                                                                          M.get_trait_method (|
                                                                                            "core::cmp::Ord",
                                                                                            V,
                                                                                            [],
                                                                                            "cmp",
                                                                                            []
                                                                                          |),
                                                                                          [
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                self
                                                                                              |),
                                                                                              9
                                                                                            |);
                                                                                            M.SubPointer.get_tuple_field (|
                                                                                              M.read (|
                                                                                                other
                                                                                              |),
                                                                                              9
                                                                                            |)
                                                                                          ]
                                                                                        |)
                                                                                      |),
                                                                                      [
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  _ :=
                                                                                              M.is_struct_tuple (|
                                                                                                γ,
                                                                                                "core::cmp::Ordering::Equal"
                                                                                              |) in
                                                                                            M.match_operator (|
                                                                                              M.alloc (|
                                                                                                M.call_closure (|
                                                                                                  M.get_trait_method (|
                                                                                                    "core::cmp::Ord",
                                                                                                    U,
                                                                                                    [],
                                                                                                    "cmp",
                                                                                                    []
                                                                                                  |),
                                                                                                  [
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        self
                                                                                                      |),
                                                                                                      10
                                                                                                    |);
                                                                                                    M.SubPointer.get_tuple_field (|
                                                                                                      M.read (|
                                                                                                        other
                                                                                                      |),
                                                                                                      10
                                                                                                    |)
                                                                                                  ]
                                                                                                |)
                                                                                              |),
                                                                                              [
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          _ :=
                                                                                                      M.is_struct_tuple (|
                                                                                                        γ,
                                                                                                        "core::cmp::Ordering::Equal"
                                                                                                      |) in
                                                                                                    M.alloc (|
                                                                                                      M.call_closure (|
                                                                                                        M.get_trait_method (|
                                                                                                          "core::cmp::Ord",
                                                                                                          T,
                                                                                                          [],
                                                                                                          "cmp",
                                                                                                          []
                                                                                                        |),
                                                                                                        [
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              self
                                                                                                            |),
                                                                                                            11
                                                                                                          |);
                                                                                                          M.SubPointer.get_tuple_field (|
                                                                                                            M.read (|
                                                                                                              other
                                                                                                            |),
                                                                                                            11
                                                                                                          |)
                                                                                                        ]
                                                                                                      |)
                                                                                                    |)));
                                                                                                fun
                                                                                                    γ =>
                                                                                                  ltac:(M.monadic
                                                                                                    (let
                                                                                                          ordering :=
                                                                                                      M.copy (|
                                                                                                        γ
                                                                                                      |) in
                                                                                                    ordering))
                                                                                              ]
                                                                                            |)));
                                                                                        fun γ =>
                                                                                          ltac:(M.monadic
                                                                                            (let
                                                                                                  ordering :=
                                                                                              M.copy (|
                                                                                                γ
                                                                                              |) in
                                                                                            ordering))
                                                                                      ]
                                                                                    |)));
                                                                                fun γ =>
                                                                                  ltac:(M.monadic
                                                                                    (let ordering :=
                                                                                      M.copy (|
                                                                                        γ
                                                                                      |) in
                                                                                    ordering))
                                                                              ]
                                                                            |)));
                                                                        fun γ =>
                                                                          ltac:(M.monadic
                                                                            (let ordering :=
                                                                              M.copy (| γ |) in
                                                                            ordering))
                                                                      ]
                                                                    |)));
                                                                fun γ =>
                                                                  ltac:(M.monadic
                                                                    (let ordering :=
                                                                      M.copy (| γ |) in
                                                                    ordering))
                                                              ]
                                                            |)));
                                                        fun γ =>
                                                          ltac:(M.monadic
                                                            (let ordering := M.copy (| γ |) in
                                                            ordering))
                                                      ]
                                                    |)));
                                                fun γ =>
                                                  ltac:(M.monadic
                                                    (let ordering := M.copy (| γ |) in
                                                    ordering))
                                              ]
                                            |)));
                                        fun γ =>
                                          ltac:(M.monadic
                                            (let ordering := M.copy (| γ |) in
                                            ordering))
                                      ]
                                    |)));
                                fun γ =>
                                  ltac:(M.monadic
                                    (let ordering := M.copy (| γ |) in
                                    ordering))
                              ]
                            |)));
                        fun γ =>
                          ltac:(M.monadic
                            (let ordering := M.copy (| γ |) in
                            ordering))
                      ]
                    |)));
                fun γ =>
                  ltac:(M.monadic
                    (let ordering := M.copy (| γ |) in
                    ordering))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::cmp::Ord"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("cmp", InstanceField.Method (cmp E D C B A Z Y X W V U T)) ].
  End Impl_core_cmp_Ord_where_core_cmp_Ord_E_where_core_cmp_Ord_D_where_core_cmp_Ord_C_where_core_cmp_Ord_B_where_core_cmp_Ord_A_where_core_cmp_Ord_Z_where_core_cmp_Ord_Y_where_core_cmp_Ord_X_where_core_cmp_Ord_W_where_core_cmp_Ord_V_where_core_cmp_Ord_U_where_core_cmp_Ord_T_where_core_marker_Sized_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_default_Default_where_core_default_Default_E_where_core_default_Default_D_where_core_default_Default_C_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
    Definition Self (E D C B A Z Y X W V U T : Ty.t) : Ty.t :=
      Ty.tuple [ E; D; C; B; A; Z; Y; X; W; V; U; T ].
    
    (*
                    fn default() -> ($($T,)+) {
                        ($({ let x: $T = Default::default(); x},)+)
                    }
    *)
    Definition default
        (E D C B A Z Y X W V U T : Ty.t)
        (ε : list Value.t)
        (τ : list Ty.t)
        (α : list Value.t)
        : M :=
      let Self : Ty.t := Self E D C B A Z Y X W V U T in
      match ε, τ, α with
      | [], [], [] =>
        ltac:(M.monadic
          (Value.Tuple
            [
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", E, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", D, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", C, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", B, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", A, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Z, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", Y, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", X, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", W, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", V, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", U, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |);
              M.read (|
                let~ x :=
                  M.alloc (|
                    M.call_closure (|
                      M.get_trait_method (| "core::default::Default", T, [], "default", [] |),
                      []
                    |)
                  |) in
                x
              |)
            ]))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (E D C B A Z Y X W V U T : Ty.t),
      M.IsTraitInstance
        "core::default::Default"
        (Self E D C B A Z Y X W V U T)
        (* Trait polymorphic types *) []
        (* Instance *) [ ("default", InstanceField.Method (default E D C B A Z Y X W V U T)) ].
  End Impl_core_default_Default_where_core_default_Default_E_where_core_default_Default_D_where_core_default_Default_C_where_core_default_Default_B_where_core_default_Default_A_where_core_default_Default_Z_where_core_default_Default_Y_where_core_default_Default_X_where_core_default_Default_W_where_core_default_Default_V_where_core_default_Default_U_where_core_default_Default_T_for_Tuple_E_D_C_B_A_Z_Y_X_W_V_U_T_.
  
  Module Impl_core_convert_From_array_Usize_12_T_for_Tuple_T_T_T_T_T_T_T_T_T_T_T_T_.
    Definition Self (T : Ty.t) : Ty.t := Ty.tuple [ T; T; T; T; T; T; T; T; T; T; T; T ].
    
    (*
                    fn from(array: [T; ${count($T)}]) -> Self {
                        let [$($T,)+] = array;
                        ($($T,)+)
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ array ] =>
        ltac:(M.monadic
          (let array := M.alloc (| array |) in
          M.read (|
            M.match_operator (|
              array,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_slice_index (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_slice_index (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_slice_index (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_slice_index (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_slice_index (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_slice_index (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_slice_index (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_slice_index (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_slice_index (| γ, 8 |) in
                    let γ0_9 := M.SubPointer.get_slice_index (| γ, 9 |) in
                    let γ0_10 := M.SubPointer.get_slice_index (| γ, 10 |) in
                    let γ0_11 := M.SubPointer.get_slice_index (| γ, 11 |) in
                    let value_E := M.copy (| γ0_0 |) in
                    let value_D := M.copy (| γ0_1 |) in
                    let value_C := M.copy (| γ0_2 |) in
                    let value_B := M.copy (| γ0_3 |) in
                    let value_A := M.copy (| γ0_4 |) in
                    let value_Z := M.copy (| γ0_5 |) in
                    let value_Y := M.copy (| γ0_6 |) in
                    let value_X := M.copy (| γ0_7 |) in
                    let value_W := M.copy (| γ0_8 |) in
                    let value_V := M.copy (| γ0_9 |) in
                    let value_U := M.copy (| γ0_10 |) in
                    let value_T := M.copy (| γ0_11 |) in
                    M.alloc (|
                      Value.Tuple
                        [
                          M.read (| value_E |);
                          M.read (| value_D |);
                          M.read (| value_C |);
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *)
        [ (* T *) Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 12 ] [ T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_array_Usize_12_T_for_Tuple_T_T_T_T_T_T_T_T_T_T_T_T_.
  
  Module Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T_T_T_T__for_array_Usize_12_T.
    Definition Self (T : Ty.t) : Ty.t :=
      Ty.apply (Ty.path "array") [ Value.Integer IntegerKind.Usize 12 ] [ T ].
    
    (*
                    fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
                        let ($($T,)+) = tuple;
                        [$($T,)+]
                    }
    *)
    Definition from (T : Ty.t) (ε : list Value.t) (τ : list Ty.t) (α : list Value.t) : M :=
      let Self : Ty.t := Self T in
      match ε, τ, α with
      | [], [], [ tuple ] =>
        ltac:(M.monadic
          (let tuple := M.alloc (| tuple |) in
          M.read (|
            M.match_operator (|
              tuple,
              [
                fun γ =>
                  ltac:(M.monadic
                    (let γ0_0 := M.SubPointer.get_tuple_field (| γ, 0 |) in
                    let γ0_1 := M.SubPointer.get_tuple_field (| γ, 1 |) in
                    let γ0_2 := M.SubPointer.get_tuple_field (| γ, 2 |) in
                    let γ0_3 := M.SubPointer.get_tuple_field (| γ, 3 |) in
                    let γ0_4 := M.SubPointer.get_tuple_field (| γ, 4 |) in
                    let γ0_5 := M.SubPointer.get_tuple_field (| γ, 5 |) in
                    let γ0_6 := M.SubPointer.get_tuple_field (| γ, 6 |) in
                    let γ0_7 := M.SubPointer.get_tuple_field (| γ, 7 |) in
                    let γ0_8 := M.SubPointer.get_tuple_field (| γ, 8 |) in
                    let γ0_9 := M.SubPointer.get_tuple_field (| γ, 9 |) in
                    let γ0_10 := M.SubPointer.get_tuple_field (| γ, 10 |) in
                    let γ0_11 := M.SubPointer.get_tuple_field (| γ, 11 |) in
                    let value_E := M.copy (| γ0_0 |) in
                    let value_D := M.copy (| γ0_1 |) in
                    let value_C := M.copy (| γ0_2 |) in
                    let value_B := M.copy (| γ0_3 |) in
                    let value_A := M.copy (| γ0_4 |) in
                    let value_Z := M.copy (| γ0_5 |) in
                    let value_Y := M.copy (| γ0_6 |) in
                    let value_X := M.copy (| γ0_7 |) in
                    let value_W := M.copy (| γ0_8 |) in
                    let value_V := M.copy (| γ0_9 |) in
                    let value_U := M.copy (| γ0_10 |) in
                    let value_T := M.copy (| γ0_11 |) in
                    M.alloc (|
                      Value.Array
                        [
                          M.read (| value_E |);
                          M.read (| value_D |);
                          M.read (| value_C |);
                          M.read (| value_B |);
                          M.read (| value_A |);
                          M.read (| value_Z |);
                          M.read (| value_Y |);
                          M.read (| value_X |);
                          M.read (| value_W |);
                          M.read (| value_V |);
                          M.read (| value_U |);
                          M.read (| value_T |)
                        ]
                    |)))
              ]
            |)
          |)))
      | _, _, _ => M.impossible "wrong number of arguments"
      end.
    
    Axiom Implements :
      forall (T : Ty.t),
      M.IsTraitInstance
        "core::convert::From"
        (Self T)
        (* Trait polymorphic types *) [ (* T *) Ty.tuple [ T; T; T; T; T; T; T; T; T; T; T; T ] ]
        (* Instance *) [ ("from", InstanceField.Method (from T)) ].
  End Impl_core_convert_From_Tuple_T_T_T_T_T_T_T_T_T_T_T_T__for_array_Usize_12_T.
End tuple.
